title=Cheatsheet
date=2022-04-15
type=page
status=published
~~~~~~

<h2>Clojure 1.11 Cheat Sheet (v54)</h2>

<p><a href="https://github.com/clojure/clojure-cheatsheets/blob/master/pdf/cheatsheet-usletter-color.pdf?raw=true">Download PDF version</a> / <a href="https://jafingerhut.github.io/">Source repo</a></p>

<p><em>Many thanks to Steve Tayon for creating it and Andy Fingerhut for ongoing maintenance.</em></p>

<script language="JavaScript" type="text/javascript">
//<![CDATA[
document.write('<style type="text/css">code {\n	font-family: monospace;\n}\n\n.page {\n	page-break-after: always;\n	page-break-inside: avoid;\n}\n\n.column {\n	float: left;\n	padding: 0;\n	margin: 0;\n	width: 50%;\n}\n\n.column:first-child {\n	clear: both;\n}\n\n.header {\n	text-align: center;\n}\n\n.header h2 {\n	font-style: italic;\n}\n\nh1 {\n	font-size: 1.8em;\n}\n\nh2 {\n	font-size: 1.4em;\n}\n\nh3 {\n	font-size: 1.2em;\n}\n\n.section {\n	background-color: #ebebeb;\n	margin: 0.5em;\n	padding: 0 0.5em 0.5em;\n}\n\ntable {\n	width: 100%;\n	border-collapse: collapse;\n}\n\ntd, .single_row {\n	vertical-align: top;\n	padding: 0 0.5em;\n}\n\ntr.odd, .single_row {\n	background-color: #f5f5f5;\n}\n\ntr.even {\n	background-color: #fafafa;\n}\n\n.footer {\n	float: right;\n	text-align: right;\n	border-top: 1px solid gray;\n}\n\n#foot {\n	clear: both;\n}\n<\/style>')
//]]>
</script>
    <div class="page">
      <div class="column">
        <div class="section">
          <h2>Documentation</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>clojure.repl/</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.repl/doc" title="clojure.repl/doc
([name])
Macro
  Prints documentation for a var or special form given its name,
   or for a spec if given a keyword">doc</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/find-doc" title="clojure.repl/find-doc
([re-string-or-pattern])
  Prints documentation for any var whose documentation or name
 contains a match for re-string-or-pattern">find-doc</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/apropos" title="clojure.repl/apropos
([str-or-pattern])
  Given a regular expression or stringable thing, return a seq of all
public definitions in all currently-loaded namespaces that match the
str-or-pattern.">apropos</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/dir" title="clojure.repl/dir
([nsname])
Macro
  Prints a sorted directory of public vars in a namespace">dir</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/source" title="clojure.repl/source
([n])
Macro
  Prints the source code for the given symbol, if it can find it.
  This requires that the symbol resolve to a Var defined in a
  namespace for which the .clj is in the classpath.

  Example: (source filter)">source</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/pst" title="clojure.repl/pst
([] [e-or-depth] [e depth])
  Prints a stack trace of the exception, to the depth requested. If none
supplied, uses the root cause of the
  most recent repl exception (*e), and a depth of 12.">pst</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.javadoc/javadoc" title="clojure.java.javadoc/javadoc
([class-or-object])
  Opens a browser window displaying the javadoc for the argument.
  Tries *local-javadocs* first, then *remote-javadocs*.">javadoc</a> (foo.bar/ is namespace for later syms)</code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Primitives</h2>
          <h3>Numbers</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Literals</td>
                <td><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html">Long</a>: 7, hex 0xff, oct 017, base 2 2r1011, base 36 36rCRAZY BigInt: 7N Ratio: -22/7 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html">Double</a>: 2.78 -1.2e-5 <a href="https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html">BigDecimal</a>: 4.2M</code></td>
              </tr>
              <tr class="even">
                <td>Arithmetic</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/%2B" title="clojure.core/+
([] [x] [x y] [x y &amp; more])
  Returns the sum of nums. (+) returns 0. Does not auto-promote
  longs, will throw on overflow. See also: +'">+</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-" title="clojure.core/-
([x] [x y] [x y &amp; more])
  If no ys are supplied, returns the negation of x, else subtracts
  the ys from x and returns the result. Does not auto-promote
  longs, will throw on overflow. See also: -'">-</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*" title="clojure.core/*
([] [x] [x y] [x y &amp; more])
  Returns the product of nums. (*) returns 1. Does not auto-promote
  longs, will throw on overflow. See also: *'">*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/_fs" title="clojure.core//
([x] [x y] [x y &amp; more])
  If no denominators are supplied, returns 1/numerator,
  else returns numerator divided by all of the denominators.">/</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/quot" title="clojure.core/quot
([num div])
  quot[ient] of dividing numerator by denominator.">quot</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rem" title="clojure.core/rem
([num div])
  remainder of dividing numerator by denominator.">rem</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mod" title="clojure.core/mod
([num div])
  Modulus of num and div. Truncates toward negative infinity.">mod</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/inc" title="clojure.core/inc
([x])
  Returns a number one greater than num. Does not auto-promote
  longs, will throw on overflow. See also: inc'">inc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dec" title="clojure.core/dec
([x])
  Returns a number one less than num. Does not auto-promote
  longs, will throw on overflow. See also: dec'">dec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/max" title="clojure.core/max
([x] [x y] [x y &amp; more])
  Returns the greatest of the nums.">max</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/min" title="clojure.core/min
([x] [x y] [x y &amp; more])
  Returns the least of the nums.">min</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/%2B%27" title="clojure.core/+'
([] [x] [x y] [x y &amp; more])
  Returns the sum of nums. (+') returns 0. Supports arbitrary precision.
  See also: +">+'</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-%27" title="clojure.core/-'
([x] [x y] [x y &amp; more])
  If no ys are supplied, returns the negation of x, else subtracts
  the ys from x and returns the result. Supports arbitrary precision.
  See also: -">-'</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*%27" title="clojure.core/*'
([] [x] [x y] [x y &amp; more])
  Returns the product of nums. (*') returns 1. Supports arbitrary precision.
  See also: *">*'</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/inc%27" title="clojure.core/inc'
([x])
  Returns a number one greater than num. Supports arbitrary precision.
  See also: inc">inc'</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dec%27" title="clojure.core/dec'
([x])
  Returns a number one less than num. Supports arbitrary precision.
  See also: dec">dec'</a> (1.11) <a href="https://clojuredocs.org/clojure_core/clojure.core/abs" title="clojure.core/abs
([a])
  Returns the absolute value of a.
  If a is Long/MIN_VALUE =&gt; Long/MIN_VALUE
  If a is a double and zero =&gt; +0.0
  If a is a double and ##Inf or ##-Inf =&gt; ##Inf
  If a is a double and ##NaN =&gt; ##NaN">abs</a></code></td>
              </tr>
              <tr class="odd">
                <td>Compare</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/%3D%3D" title="clojure.core/==
([x] [x y] [x y &amp; more])
  Returns non-nil if nums all have the equivalent
  value (type-independent), otherwise false">==</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/%3C" title="clojure.core/&lt;
([x] [x y] [x y &amp; more])
  Returns non-nil if nums are in monotonically increasing order,
  otherwise false.">&lt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/%3E" title="clojure.core/&gt;
([x] [x y] [x y &amp; more])
  Returns non-nil if nums are in monotonically decreasing order,
  otherwise false.">&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/%3C%3D" title="clojure.core/&lt;=
([x] [x y] [x y &amp; more])
  Returns non-nil if nums are in monotonically non-decreasing order,
  otherwise false.">&lt;=</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/%3E%3D" title="clojure.core/&gt;=
([x] [x y] [x y &amp; more])
  Returns non-nil if nums are in monotonically non-increasing order,
  otherwise false.">&gt;=</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compare" title="clojure.core/compare
([x y])
  Comparator. Returns a negative number, zero, or a positive number
  when x is logically 'less than', 'equal to', or 'greater than'
  y. Same as Java x.compareTo(y) except it also works for nil, and
  compares numbers and collections in a type-independent manner. x
  must implement Comparable">compare</a></code></td>
              </tr>
              <tr class="even">
                <td>Bitwise</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/bit-and" title="clojure.core/bit-and
([x y] [x y &amp; more])
  Bitwise and">bit-and</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-or" title="clojure.core/bit-or
([x y] [x y &amp; more])
  Bitwise or">bit-or</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-xor" title="clojure.core/bit-xor
([x y] [x y &amp; more])
  Bitwise exclusive or">bit-xor</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-not" title="clojure.core/bit-not
([x])
  Bitwise complement">bit-not</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-flip" title="clojure.core/bit-flip
([x n])
  Flip bit at index n">bit-flip</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-set" title="clojure.core/bit-set
([x n])
  Set bit at index n">bit-set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-shift-right" title="clojure.core/bit-shift-right
([x n])
  Bitwise shift right">bit-shift-right</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-shift-left" title="clojure.core/bit-shift-left
([x n])
  Bitwise shift left">bit-shift-left</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-and-not" title="clojure.core/bit-and-not
([x y] [x y &amp; more])
  Bitwise and with complement">bit-and-not</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-clear" title="clojure.core/bit-clear
([x n])
  Clear bit at index n">bit-clear</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bit-test" title="clojure.core/bit-test
([x n])
  Test bit at index n">bit-test</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unsigned-bit-shift-right" title="clojure.core/unsigned-bit-shift-right
([x n])
  Bitwise shift right, without sign-extension.">unsigned-bit-shift-right</a> (see <a href="https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html">BigInteger</a>  for integers larger than Long)</code></td>
              </tr>
              <tr class="odd">
                <td>Cast</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/byte" title="clojure.core/byte
([x])
  Coerce to byte">byte</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/short" title="clojure.core/short
([x])
  Coerce to short">short</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/int" title="clojure.core/int
([x])
  Coerce to int">int</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/long" title="clojure.core/long
([x])
  Coerce to long">long</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/float" title="clojure.core/float
([x])
  Coerce to float">float</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/double" title="clojure.core/double
([x])
  Coerce to double">double</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bigdec" title="clojure.core/bigdec
([x])
  Coerce to BigDecimal">bigdec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bigint" title="clojure.core/bigint
([x])
  Coerce to BigInt">bigint</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/num" title="clojure.core/num
([x])
  Coerce to Number">num</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rationalize" title="clojure.core/rationalize
([num])
  returns the rational value of num">rationalize</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/biginteger" title="clojure.core/biginteger
([x])
  Coerce to BigInteger">biginteger</a></code></td>
              </tr>
              <tr class="even">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/zero_q" title="clojure.core/zero?
([num])
  Returns true if num is zero, else false">zero?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pos_q" title="clojure.core/pos?
([num])
  Returns true if num is greater than zero, else false">pos?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/neg_q" title="clojure.core/neg?
([num])
  Returns true if num is less than zero, else false">neg?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/even_q" title="clojure.core/even?
([n])
  Returns true if n is even, throws an exception if n is not an integer">even?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/odd_q" title="clojure.core/odd?
([n])
  Returns true if n is odd, throws an exception if n is not an integer">odd?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/number_q" title="clojure.core/number?
([x])
  Returns true if x is a Number">number?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rational_q" title="clojure.core/rational?
([n])
  Returns true if n is a rational number">rational?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/integer_q" title="clojure.core/integer?
([n])
  Returns true if n is an integer">integer?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ratio_q" title="clojure.core/ratio?
([n])
  Returns true if n is a Ratio">ratio?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/decimal_q" title="clojure.core/decimal?
([n])
  Returns true if n is a BigDecimal">decimal?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/float_q" title="clojure.core/float?
([n])
  Returns true if n is a floating point number">float?</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/double_q" title="clojure.core/double?
([x])
  Return true if x is a Double">double?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/int_q" title="clojure.core/int?
([x])
  Return true if x is a fixed precision integer">int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nat-int_q" title="clojure.core/nat-int?
([x])
  Return true if x is a non-negative fixed precision integer">nat-int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/neg-int_q" title="clojure.core/neg-int?
([x])
  Return true if x is a negative fixed precision integer">neg-int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pos-int_q" title="clojure.core/pos-int?
([x])
  Return true if x is a positive fixed precision integer">pos-int?</a> (1.11) <a href="https://clojuredocs.org/clojure_core/clojure.core/NaN_q" title="clojure.core/NaN?
([num])
  Returns true if num is NaN, else false">NaN?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/infinite_q" title="clojure.core/infinite?
([num])
  Returns true if num is negative or positive infinity, else false">infinite?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Random</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/rand" title="clojure.core/rand
([] [n])
  Returns a random floating point number between 0 (inclusive) and
  n (default 1) (exclusive).">rand</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rand-int" title="clojure.core/rand-int
([n])
  Returns a random integer between 0 (inclusive) and n (exclusive).">rand-int</a></code></td>
              </tr>
              <tr class="even">
                <td>BigDecimal</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/with-precision" title="clojure.core/with-precision
([precision &amp; exprs])
Macro
  Sets the precision and rounding mode to be used for BigDecimal operations.

  Usage: (with-precision 10 (/ 1M 3))
  or:    (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.">with-precision</a></code></td>
              </tr>
              <tr class="odd">
                <td>Unchecked</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*unchecked-math*" title="clojure.core/*unchecked-math*
  While bound to true, compilations of +, -, *, inc, dec and the
  coercions will be done without overflow checks. While bound
  to :warn-on-boxed, same behavior as true, and a warning is emitted
  when compilation uses boxed math. Default: false.">*unchecked-math*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-add" title="clojure.core/unchecked-add
([x y])
  Returns the sum of x and y, both long.
  Note - uses a primitive operator subject to overflow.">unchecked-add</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-dec" title="clojure.core/unchecked-dec
([x])
  Returns a number one less than x, a long.
  Note - uses a primitive operator subject to overflow.">unchecked-dec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-inc" title="clojure.core/unchecked-inc
([x])
  Returns a number one greater than x, a long.
  Note - uses a primitive operator subject to overflow.">unchecked-inc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-multiply" title="clojure.core/unchecked-multiply
([x y])
  Returns the product of x and y, both long.
  Note - uses a primitive operator subject to overflow.">unchecked-multiply</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-negate" title="clojure.core/unchecked-negate
([x])
  Returns the negation of x, a long.
  Note - uses a primitive operator subject to overflow.">unchecked-negate</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unchecked-subtract" title="clojure.core/unchecked-subtract
([x y])
  Returns the difference of x and y, both long.
  Note - uses a primitive operator subject to overflow.">unchecked-subtract</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Strings</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/str" title="clojure.core/str
([] [x] [x &amp; ys])
  With no args, returns the empty string. With one arg x, returns
  x.toString().  (str nil) returns the empty string. With more than
  one arg, returns the concatenation of the str values of the args.">str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/format" title="clojure.core/format
([fmt &amp; args])
  Formats a string using java.lang.String.format, see java.util.Formatter for
format
  string syntax">format</a> <a href="https://clojure.org/reference/reader#_literals">"a string"</a> "escapes \b\f\n\t\r\" octal \377 hex \ucafe" See also section IO/to string</code></td>
              </tr>
              <tr class="even">
                <td>Use</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/count" title="clojure.core/count
([coll])
  Returns the number of items in the collection. (count nil) returns
  0.  Also works on strings, arrays, and Java Collections and Maps">count</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get" title="clojure.core/get
([map key] [map key not-found])
  Returns the value mapped to key, not-found or nil if key not present
  in associative collection, set, string, array, or ILookup instance.">get</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/subs" title="clojure.core/subs
([s start] [s start end])
  Returns the substring of s beginning at start inclusive, and ending
  at end (defaults to length of string), exclusive.">subs</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compare" title="clojure.core/compare
([x y])
  Comparator. Returns a negative number, zero, or a positive number
  when x is logically 'less than', 'equal to', or 'greater than'
  y. Same as Java x.compareTo(y) except it also works for nil, and
  compares numbers and collections in a type-independent manner. x
  must implement Comparable">compare</a> (clojure.string/) <a href="https://clojuredocs.org/clojure_core/clojure.string/join" title="clojure.string/join
([coll] [separator coll])
  Returns a string of all elements in coll, as returned by (seq coll),
   separated by an optional separator.">join</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/escape" title="clojure.string/escape
([s cmap])
  Return a new string, using cmap to escape each character ch
   from s as follows:

   If (cmap ch) is nil, append ch to the new string.
   If (cmap ch) is non-nil, append (str (cmap ch)) instead.">escape</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/split" title="clojure.string/split
([s re] [s re limit])
  Splits string on a regular expression.  Optional argument limit is
  the maximum number of parts. Not lazy. Returns vector of the parts.
  Trailing empty strings are not returned - pass limit of -1 to return all.">split</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/split-lines" title="clojure.string/split-lines
([s])
  Splits s on \n or \r\n. Trailing empty lines are not returned.">split-lines</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/replace" title="clojure.string/replace
([s match replacement])
  Replaces all instance of match with replacement in s.

   match/replacement can be:

   string / string
   char / char
   pattern / (string or function of match).

   See also replace-first.

   The replacement is literal (i.e. none of its characters are treated
   specially) for all cases above except pattern / string.

   For pattern / string, $1, $2, etc. in the replacement string are
   substituted with the string that matched the corresponding
   parenthesized group in the pattern.  If you wish your replacement
   string r to be used literally, use (re-quote-replacement r) as the
   replacement argument.  See also documentation for
   java.util.regex.Matcher's appendReplacement method.

   Example:
   (clojure.string/replace &quot;Almost Pig Latin&quot; #&quot;\b(\w)(\w+)\b&quot; &quot;$2$1ay&quot;)
   -&gt; &quot;lmostAay igPay atinLay&quot;">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/replace-first" title="clojure.string/replace-first
([s match replacement])
  Replaces the first instance of match with replacement in s.

   match/replacement can be:

   char / char
   string / string
   pattern / (string or function of match).

   See also replace.

   The replacement is literal (i.e. none of its characters are treated
   specially) for all cases above except pattern / string.

   For pattern / string, $1, $2, etc. in the replacement string are
   substituted with the string that matched the corresponding
   parenthesized group in the pattern.  If you wish your replacement
   string r to be used literally, use (re-quote-replacement r) as the
   replacement argument.  See also documentation for
   java.util.regex.Matcher's appendReplacement method.

   Example:
   (clojure.string/replace-first &quot;swap first two words&quot;
                                 #&quot;(\w+)(\s+)(\w+)&quot; &quot;$3$2$1&quot;)

[ documentation truncated.  Click link for the rest. ]">replace-first</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/reverse" title="clojure.string/reverse
([s])
  Returns s with its characters reversed.">reverse</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/index-of" title="clojure.string/index-of
([s value] [s value from-index])
  Return index of value (string or char) in s, optionally searching
  forward from from-index. Return nil if value not found.">index-of</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/last-index-of" title="clojure.string/last-index-of
([s value] [s value from-index])
  Return last index of value (string or char) in s, optionally
  searching backward from from-index. Return nil if value not found.">last-index-of</a> (1.11) (clojure.core/) <a href="https://clojuredocs.org/clojure_core/clojure.core/parse-boolean" title="clojure.core/parse-boolean
([s])
  Parse strings &quot;true&quot; or &quot;false&quot; and return a boolean, or nil if invalid">parse-boolean</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/parse-double" title="clojure.core/parse-double
([s])
  Parse string with floating point components and return a Double value,
  or nil if parse fails.

  Grammar:
https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-">parse-double</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/parse-long" title="clojure.core/parse-long
([s])
  Parse string of decimal digits with optional leading -/+ and return a
  Long value, or nil if parse fails">parse-long</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/parse-uuid" title="clojure.core/parse-uuid
([s])
  Parse a string representing a UUID and return a java.util.UUID instance,
  or nil if parse fails.

  Grammar:
https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--">parse-uuid</a></code></td>
              </tr>
              <tr class="odd">
                <td><a href="http://www.regular-expressions.info">Regex</a></td>
                <td><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">#"<var>pattern</var>"</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-find" title="clojure.core/re-find
([m] [re s])
  Returns the next regex match, if any, of string to pattern, using
  java.util.regex.Matcher.find().  Uses re-groups to return the
  groups.">re-find</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-seq" title="clojure.core/re-seq
([re s])
  Returns a lazy sequence of successive matches of pattern in string,
  using java.util.regex.Matcher.find(), each such match processed with
  re-groups.">re-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-matches" title="clojure.core/re-matches
([re s])
  Returns the match, if any, of string to pattern, using
  java.util.regex.Matcher.matches().  Uses re-groups to return the
  groups.">re-matches</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-pattern" title="clojure.core/re-pattern
([s])
  Returns an instance of java.util.regex.Pattern, for use, e.g. in
  re-matcher.">re-pattern</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-matcher" title="clojure.core/re-matcher
([re s])
  Returns an instance of java.util.regex.Matcher, for use, e.g. in
  re-find.">re-matcher</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-groups" title="clojure.core/re-groups
([m])
  Returns the groups from the most recent match/find. If there are no
  nested groups, returns a string of the entire match. If there are
  nested groups, returns a vector of the groups, the first element
  being the entire match.">re-groups</a> (clojure.string/) <a href="https://clojuredocs.org/clojure_core/clojure.string/replace" title="clojure.string/replace
([s match replacement])
  Replaces all instance of match with replacement in s.

   match/replacement can be:

   string / string
   char / char
   pattern / (string or function of match).

   See also replace-first.

   The replacement is literal (i.e. none of its characters are treated
   specially) for all cases above except pattern / string.

   For pattern / string, $1, $2, etc. in the replacement string are
   substituted with the string that matched the corresponding
   parenthesized group in the pattern.  If you wish your replacement
   string r to be used literally, use (re-quote-replacement r) as the
   replacement argument.  See also documentation for
   java.util.regex.Matcher's appendReplacement method.

   Example:
   (clojure.string/replace &quot;Almost Pig Latin&quot; #&quot;\b(\w)(\w+)\b&quot; &quot;$2$1ay&quot;)
   -&gt; &quot;lmostAay igPay atinLay&quot;">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/replace-first" title="clojure.string/replace-first
([s match replacement])
  Replaces the first instance of match with replacement in s.

   match/replacement can be:

   char / char
   string / string
   pattern / (string or function of match).

   See also replace.

   The replacement is literal (i.e. none of its characters are treated
   specially) for all cases above except pattern / string.

   For pattern / string, $1, $2, etc. in the replacement string are
   substituted with the string that matched the corresponding
   parenthesized group in the pattern.  If you wish your replacement
   string r to be used literally, use (re-quote-replacement r) as the
   replacement argument.  See also documentation for
   java.util.regex.Matcher's appendReplacement method.

   Example:
   (clojure.string/replace-first &quot;swap first two words&quot;
                                 #&quot;(\w+)(\s+)(\w+)&quot; &quot;$3$2$1&quot;)

[ documentation truncated.  Click link for the rest. ]">replace-first</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/re-quote-replacement" title="clojure.string/re-quote-replacement
([replacement])
  Given a replacement string that you wish to be a literal
   replacement for a pattern match in replace or replace-first, do the
   necessary escaping of special characters in the replacement.">re-quote-replacement</a> Note: \ in <code>#""</code> is not escape char. <code>(re-pattern "\\s*\\d+")</code> can be written <code>#"\s*\d+"</code></code></td>
              </tr>
              <tr class="even">
                <td>Letters</td>
                <td><code>(clojure.string/) <a href="https://clojuredocs.org/clojure_core/clojure.string/capitalize" title="clojure.string/capitalize
([s])
  Converts first character of the string to upper-case, all other
  characters to lower-case.">capitalize</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/lower-case" title="clojure.string/lower-case
([s])
  Converts string to all lower-case.">lower-case</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/upper-case" title="clojure.string/upper-case
([s])
  Converts string to all upper-case.">upper-case</a></code></td>
              </tr>
              <tr class="odd">
                <td>Trim</td>
                <td><code>(clojure.string/) <a href="https://clojuredocs.org/clojure_core/clojure.string/trim" title="clojure.string/trim
([s])
  Removes whitespace from both ends of string.">trim</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/trim-newline" title="clojure.string/trim-newline
([s])
  Removes all trailing newline \n or return \r characters from
  string.  Similar to Perl's chomp.">trim-newline</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/triml" title="clojure.string/triml
([s])
  Removes whitespace from the left side of string.">triml</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/trimr" title="clojure.string/trimr
([s])
  Removes whitespace from the right side of string.">trimr</a></code></td>
              </tr>
              <tr class="even">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/string_q" title="clojure.core/string?
([x])
  Return true if x is a String">string?</a> (clojure.string/) <a href="https://clojuredocs.org/clojure_core/clojure.string/blank_q" title="clojure.string/blank?
([s])
  True if s is nil, empty, or contains only whitespace.">blank?</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/starts-with_q" title="clojure.string/starts-with?
([s substr])
  True if s starts with substr.">starts-with?</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/ends-with_q" title="clojure.string/ends-with?
([s substr])
  True if s ends with substr.">ends-with?</a> <a href="https://clojuredocs.org/clojure_core/clojure.string/includes_q" title="clojure.string/includes?
([s substr])
  True if s includes substr.">includes?</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Other</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Characters</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/char" title="clojure.core/char
([x])
  Coerce to char">char</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/char_q" title="clojure.core/char?
([x])
  Return true if x is a Character">char?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/char-name-string" title="clojure.core/char-name-string
  Returns name string for char or nil if none">char-name-string</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/char-escape-string" title="clojure.core/char-escape-string
  Returns escape string for char or nil if none">char-escape-string</a> <a href="https://clojure.org/reference/reader#_literals">literals</a>: \a \newline (more at link)</code></td>
              </tr>
              <tr class="even">
                <td>Keywords</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/keyword" title="clojure.core/keyword
([name] [ns name])
  Returns a Keyword with the given namespace and name.  Do not use :
  in the keyword strings, it will be added automatically.">keyword</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keyword_q" title="clojure.core/keyword?
([x])
  Return true if x is a Keyword">keyword?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/find-keyword" title="clojure.core/find-keyword
([name] [ns name])
  Returns a Keyword with the given namespace and name if one already
  exists.  This function will not intern a new keyword. If the keyword
  has not already been interned, it will return nil.  Do not use :
  in the keyword strings, it will be added automatically.">find-keyword</a> <a href="https://clojure.org/reference/reader#_literals">literals</a>: :kw :my.name.space/kw ::in-cur-namespace ::namespace-alias/kw</code></td>
              </tr>
              <tr class="odd">
                <td>Symbols</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/symbol" title="clojure.core/symbol
([name] [ns name])
  Returns a Symbol with the given namespace and name. Arity-1 works
  on strings, keywords, and vars.">symbol</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/symbol_q" title="clojure.core/symbol?
([x])
  Return true if x is a Symbol">symbol?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/gensym" title="clojure.core/gensym
([] [prefix-string])
  Returns a new symbol with a unique name. If a prefix string is
  supplied, the name is prefix# where # is some unique number. If
  prefix is not supplied, the prefix is 'G__'.">gensym</a> <a href="https://clojure.org/reference/reader#_literals">literals</a>: my-sym my.ns/foo</code></td>
              </tr>
              <tr class="even">
                <td>Misc</td>
                <td><code><a href="https://clojure.org/reference/reader#_literals">literals</a>: true false nil</code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Collections</h2>
          <h3>Collections</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Generic ops</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/count" title="clojure.core/count
([coll])
  Returns the number of items in the collection. (count nil) returns
  0.  Also works on strings, arrays, and Java Collections and Maps">count</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/empty" title="clojure.core/empty
([coll])
  Returns an empty collection of the same category as coll, or nil">empty</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/not-empty" title="clojure.core/not-empty
([coll])
  If coll is empty, returns nil, else coll">not-empty</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/into" title="clojure.core/into
([] [to] [to from] [to xform from])
  Returns a new coll consisting of to-coll with all of the items of
  from-coll conjoined. A transducer may be supplied.">into</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> (clojure.walk/) <a href="https://clojuredocs.org/clojure_core/clojure.walk/walk" title="clojure.walk/walk
([inner outer form])
  Traverses form, an arbitrary data structure.  inner and outer are
  functions.  Applies inner to each element of form, building up a
  data structure of the same type, then applies outer to the result.
  Recognizes all Clojure data structures. Consumes seqs as with doall.">walk</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/prewalk" title="clojure.walk/prewalk
([f form])
  Like postwalk, but does pre-order traversal.">prewalk</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/prewalk-demo" title="clojure.walk/prewalk-demo
([form])
  Demonstrates the behavior of prewalk by printing each form as it is
  walked.  Returns form.">prewalk-demo</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/prewalk-replace" title="clojure.walk/prewalk-replace
([smap form])
  Recursively transforms form by replacing keys in smap with their
  values.  Like clojure/replace but works on any data structure.  Does
  replacement at the root of the tree first.">prewalk-replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/postwalk" title="clojure.walk/postwalk
([f form])
  Performs a depth-first, post-order traversal of form.  Calls f on
  each sub-form, uses f's return value in place of the original.
  Recognizes all Clojure data structures. Consumes seqs as with doall.">postwalk</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/postwalk-demo" title="clojure.walk/postwalk-demo
([form])
  Demonstrates the behavior of postwalk by printing each form as it is
  walked.  Returns form.">postwalk-demo</a> <a href="https://clojuredocs.org/clojure_core/clojure.walk/postwalk-replace" title="clojure.walk/postwalk-replace
([smap form])
  Recursively transforms form by replacing keys in smap with their
  values.  Like clojure/replace but works on any data structure.  Does
  replacement at the leaves of the tree first.">postwalk-replace</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/bounded-count" title="clojure.core/bounded-count
([n coll])
  If coll is counted? returns its count, else will count at most the first n
  elements of coll using its seq">bounded-count</a></code></td>
              </tr>
              <tr class="even">
                <td>Content tests</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/distinct_q" title="clojure.core/distinct?
([x] [x y] [x y &amp; more])
  Returns true if no two of the arguments are =">distinct?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/empty_q" title="clojure.core/empty?
([coll])
  Returns true if coll has no items - same as (not (seq coll)).
  Please use the idiom (seq x) rather than (not (empty? x))">empty?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/every_q" title="clojure.core/every?
([pred coll])
  Returns true if (pred x) is logical true for every x in coll, else
  false.">every?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/not-every_q" title="clojure.core/not-every?
([pred coll])
  Returns false if (pred x) is logical true for every x in
  coll, else true.">not-every?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some" title="clojure.core/some
([pred coll])
  Returns the first logical true value of (pred x) for any x in coll,
  else nil.  One common idiom is to use a set as pred, for example
  this will return :fred if :fred is in the sequence, otherwise nil:
  (some #{:fred} coll)">some</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/not-any_q" title="clojure.core/not-any?
([pred coll])
  Returns false if (pred x) is logical true for any x in coll,
  else true.">not-any?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Capabilities</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/sequential_q" title="clojure.core/sequential?
([coll])
  Returns true if coll implements Sequential">sequential?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/associative_q" title="clojure.core/associative?
([coll])
  Returns true if coll implements Associative">associative?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sorted_q" title="clojure.core/sorted?
([coll])
  Returns true if coll implements Sorted">sorted?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/counted_q" title="clojure.core/counted?
([coll])
  Returns true if coll implements count in constant time">counted?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reversible_q" title="clojure.core/reversible?
([coll])
  Returns true if coll implements Reversible">reversible?</a></code></td>
              </tr>
              <tr class="even">
                <td>Type tests</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/coll_q" title="clojure.core/coll?
([x])
  Returns true if x implements IPersistentCollection">coll?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/list_q" title="clojure.core/list?
([x])
  Returns true if x implements IPersistentList">list?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vector_q" title="clojure.core/vector?
([x])
  Return true if x implements IPersistentVector">vector?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set_q" title="clojure.core/set?
([x])
  Returns true if x implements IPersistentSet">set?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/map_q" title="clojure.core/map?
([x])
  Return true if x implements IPersistentMap">map?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/seq_q" title="clojure.core/seq?
([x])
  Return true if x implements ISeq">seq?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/record_q" title="clojure.core/record?
([x])
  Returns true if x is a record">record?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/map-entry_q" title="clojure.core/map-entry?
([x])
  Return true if x is a map entry">map-entry?</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Lists (conj, pop, &amp; peek at beginning)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code>() <a href="https://clojuredocs.org/clojure_core/clojure.core/list" title="clojure.core/list
([&amp; items])
  Creates a new list containing the items.">list</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/list*" title="clojure.core/list*
([args] [a args] [a b args] [a b c args] [a b c d &amp; more])
  Creates a new seq containing the items prepended to the rest, the
  last of which will be treated as a sequence.">list*</a></code></td>
              </tr>
              <tr class="even">
                <td>Examine</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/first" title="clojure.core/first
([coll])
  Returns the first item in the collection. Calls seq on its
    argument. If coll is nil, returns nil.">first</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nth" title="clojure.core/nth
([coll index] [coll index not-found])
  Returns the value at the index. get returns nil if index out of
  bounds, nth throws an exception unless not-found is supplied.  nth
  also works for strings, Java arrays, regex Matchers and Lists, and,
  in O(n) time, for sequences.">nth</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/peek" title="clojure.core/peek
([coll])
  For a list or queue, same as first, for a vector, same as, but much
  more efficient than, last. If the collection is empty, returns nil.">peek</a> <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html#indexOf-java.lang.Object-">.indexOf</a> <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html#lastIndexOf-java.lang.Object-">.lastIndexOf</a></code></td>
              </tr>
              <tr class="odd">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/cons" title="clojure.core/cons
([x seq])
  Returns a new seq where x is the first element and seq is
    the rest.">cons</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rest" title="clojure.core/rest
([coll])
  Returns a possibly empty seq of the items after the first. Calls seq on its
  argument.">rest</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pop" title="clojure.core/pop
([coll])
  For a list or queue, returns a new list/queue without the first
  item, for a vector, returns a new vector without the last item. If
  the collection is empty, throws an exception.  Note - not the same
  as next/butlast.">pop</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Vectors (conj, pop, &amp; peek at end)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code>[] <a href="https://clojuredocs.org/clojure_core/clojure.core/vector" title="clojure.core/vector
([] [a] [a b] [a b c] [a b c d] [a b c d e] [a b c d e f] [a b c d e f &amp; args])
  Creates a new vector containing the args.">vector</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vec" title="clojure.core/vec
([coll])
  Creates a new vector containing the contents of coll. Java arrays
  will be aliased and should not be modified.">vec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vector-of" title="clojure.core/vector-of
([t] [t &amp; elements])
  Creates a new vector of a single primitive type t, where t is one
  of :int :long :float :double :byte :short :char or :boolean. The
  resulting vector complies with the interface of vectors in general,
  but stores the values unboxed internally.

  Optionally takes one or more elements to populate the vector.">vector-of</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mapv" title="clojure.core/mapv
([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 &amp; colls])
  Returns a vector consisting of the result of applying f to the
  set of first items of each coll, followed by applying f to the set
  of second items in each coll, until any one of the colls is
  exhausted.  Any remaining items in other colls are ignored. Function
  f should accept number-of-colls arguments.">mapv</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filterv" title="clojure.core/filterv
([pred coll])
  Returns a vector of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.">filterv</a></code></td>
              </tr>
              <tr class="even">
                <td>Examine</td>
                <td><code><code>(my-vec idx)</code> &rarr; <code>( <a href="https://clojuredocs.org/clojure_core/clojure.core/nth" title="clojure.core/nth
([coll index] [coll index not-found])
  Returns the value at the index. get returns nil if index out of
  bounds, nth throws an exception unless not-found is supplied.  nth
  also works for strings, Java arrays, regex Matchers and Lists, and,
  in O(n) time, for sequences.">nth</a>  my-vec idx)</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/get" title="clojure.core/get
([map key] [map key not-found])
  Returns the value mapped to key, not-found or nil if key not present
  in associative collection, set, string, array, or ILookup instance.">get</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/peek" title="clojure.core/peek
([coll])
  For a list or queue, same as first, for a vector, same as, but much
  more efficient than, last. If the collection is empty, returns nil.">peek</a> <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html#indexOf-java.lang.Object-">.indexOf</a> <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html#lastIndexOf-java.lang.Object-">.lastIndexOf</a></code></td>
              </tr>
              <tr class="odd">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/assoc" title="clojure.core/assoc
([map key val] [map key val &amp; kvs])
  assoc[iate]. When applied to a map, returns a new map of the
    same (hashed/sorted) type, that contains the mapping of key(s) to
    val(s). When applied to a vector, returns a new vector that
    contains val at index. Note - index must be &lt;= (count vector).">assoc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/assoc-in" title="clojure.core/assoc-in
([m [k &amp; ks] v])
  Associates a value in a nested associative structure, where ks is a
  sequence of keys and v is the new value and returns a new nested structure.
  If any levels do not exist, hash-maps will be created.">assoc-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pop" title="clojure.core/pop
([coll])
  For a list or queue, returns a new list/queue without the first
  item, for a vector, returns a new vector without the last item. If
  the collection is empty, throws an exception.  Note - not the same
  as next/butlast.">pop</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/subvec" title="clojure.core/subvec
([v start] [v start end])
  Returns a persistent vector of the items in vector from
  start (inclusive) to end (exclusive).  If end is not supplied,
  defaults to (count vector). This operation is O(1) and very fast, as
  the resulting vector shares structure with the original and no
  trimming is done.">subvec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/replace" title="clojure.core/replace
([smap] [smap coll])
  Given a map of replacement pairs and a vector/collection, returns a
  vector/seq with any elements = a key in smap replaced with the
  corresponding val in smap.  Returns a transducer when no collection
  is provided.">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rseq" title="clojure.core/rseq
([rev])
  Returns, in constant time, a seq of the items in rev (which
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil">rseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update" title="clojure.core/update
([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z &amp; more])
  'Updates' a value in an associative structure, where k is a
  key and f is a function that will take the old value
  and any supplied args and return the new value, and returns a new
  structure.  If the key does not exist, nil is passed as the old value.">update</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update-in" title="clojure.core/update-in
([m ks f &amp; args])
  'Updates' a value in a nested associative structure, where ks is a
  sequence of keys and f is a function that will take the old value
  and any supplied args and return the new value, and returns a new
  nested structure.  If any levels do not exist, hash-maps will be
  created.">update-in</a></code></td>
              </tr>
              <tr class="even">
                <td>Ops</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/reduce-kv" title="clojure.core/reduce-kv
([f init coll])
  Reduces an associative collection. f should be a function of 3
  arguments. Returns the result of applying f to init, the first key
  and the first value in coll, then applying f to that result and the
  2nd key and value, etc. If coll contains no entries, returns init
  and f is not called. Note that reduce-kv is supported on vectors,
  where the keys will be the ordinals.">reduce-kv</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Sets</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create unsorted</td>
                <td><code>#{} <a href="https://clojuredocs.org/clojure_core/clojure.core/set" title="clojure.core/set
([coll])
  Returns a set of the distinct elements of coll.">set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/hash-set" title="clojure.core/hash-set
([] [&amp; keys])
  Returns a new hash set with supplied keys.  Any equal keys are
  handled as if by repeated uses of conj.">hash-set</a></code></td>
              </tr>
              <tr class="even">
                <td>Create sorted</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/sorted-set" title="clojure.core/sorted-set
([&amp; keys])
  Returns a new sorted set with supplied keys.  Any equal keys are
  handled as if by repeated uses of conj.">sorted-set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sorted-set-by" title="clojure.core/sorted-set-by
([comparator &amp; keys])
  Returns a new sorted set with supplied keys, using the supplied
  comparator.  Any equal keys are handled as if by repeated uses of
  conj.">sorted-set-by</a> (clojure.data.avl/) <a href="https://github.com/clojure/data.avl" title="clojure.data.avl/sorted-set
([&amp; keys])
  Returns a new sorted set with supplied keys.">sorted-set</a> <a href="https://github.com/clojure/data.avl" title="clojure.data.avl/sorted-set-by
([comparator &amp; keys])
  Returns a new sorted set with supplied keys, using the supplied comparator.">sorted-set-by</a> (flatland.ordered.set/) <a href="https://github.com/amalloy/ordered" title="flatland.ordered.set/ordered-set
([] [&amp; xs])
  Return a set with the given items, whose items are sorted in the
order that they are added. conj'ing an item that was already in the
set leaves its order unchanged. disj'ing an item and then later
conj'ing it puts it at the end, as if it were being added for the
first time. Supports transient.

Note that clojure.set functions like union, intersection, and
difference can change the order of their input sets for efficiency
purposes, so may not return the order you expect given ordered sets
as input.">ordered-set</a> (clojure.data.int-map/) <a href="https://github.com/clojure/data.int-map" title="clojure.data.int-map/int-set
([] [s])
  Creates an immutable set which can only store integral values.  This should be
used unless elements are densely
   clustered (each element has multiple elements within +/- 1000).">int-set</a> <a href="https://github.com/clojure/data.int-map" title="clojure.data.int-map/dense-int-set
([] [s])
  Creates an immutable set which can only store integral values.  This should be
used only if elements are densely
   clustered (each element has multiple elements within +/- 1000).">dense-int-set</a></code></td>
              </tr>
              <tr class="odd">
                <td>Examine</td>
                <td><code><code>(my-set item)</code> &rarr; <code>( <a href="https://clojuredocs.org/clojure_core/clojure.core/get" title="clojure.core/get
([map key] [map key not-found])
  Returns the value mapped to key, not-found or nil if key not present
  in associative collection, set, string, array, or ILookup instance.">get</a>  my-set item)</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/contains_q" title="clojure.core/contains?
([coll key])
  Returns true if key is present in the given collection, otherwise
  returns false.  Note that for numerically indexed collections like
  vectors and Java arrays, this tests if the numeric key is within the
  range of indexes. 'contains?' operates constant or logarithmic time;
  it will not perform a linear search for a value.  See also 'some'.">contains?</a></code></td>
              </tr>
              <tr class="even">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/disj" title="clojure.core/disj
([set] [set key] [set key &amp; ks])
  disj[oin]. Returns a new set of the same (hashed/sorted) type, that
  does not contain key(s).">disj</a></code></td>
              </tr>
              <tr class="odd">
                <td>Set ops</td>
                <td><code>(clojure.set/) <a href="https://clojuredocs.org/clojure_core/clojure.set/union" title="clojure.set/union
([] [s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the union of the input sets">union</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/difference" title="clojure.set/difference
([s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the first set without elements of the remaining sets">difference</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/intersection" title="clojure.set/intersection
([s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the intersection of the input sets">intersection</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/select" title="clojure.set/select
([pred xset])
  Returns a set of the elements for which pred is true">select</a> See also section Relations</code></td>
              </tr>
              <tr class="even">
                <td>Test</td>
                <td><code>(clojure.set/) <a href="https://clojuredocs.org/clojure_core/clojure.set/subset_q" title="clojure.set/subset?
([set1 set2])
  Is set1 a subset of set2?">subset?</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/superset_q" title="clojure.set/superset?
([set1 set2])
  Is set1 a superset of set2?">superset?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Sorted sets</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/rseq" title="clojure.core/rseq
([rev])
  Returns, in constant time, a seq of the items in rev (which
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil">rseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/subseq" title="clojure.core/subseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">subseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rsubseq" title="clojure.core/rsubseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a reverse seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">rsubseq</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Maps</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create unsorted</td>
                <td><code>{} <a href="https://clojuredocs.org/clojure_core/clojure.core/hash-map" title="clojure.core/hash-map
([] [&amp; keyvals])
  keyval =&gt; key val
  Returns a new hash map with supplied mappings.  If any keys are
  equal, they are handled as if by repeated uses of assoc.">hash-map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/array-map" title="clojure.core/array-map
([] [&amp; keyvals])
  Constructs an array-map. If any keys are equal, they are handled as
  if by repeated uses of assoc.">array-map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/zipmap" title="clojure.core/zipmap
([keys vals])
  Returns a map with the keys mapped to the corresponding vals.">zipmap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bean" title="clojure.core/bean
([x])
  Takes a Java object and returns a read-only implementation of the
  map abstraction based upon its JavaBean properties.">bean</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/frequencies" title="clojure.core/frequencies
([coll])
  Returns a map from distinct items in coll to the number of times
  they appear.">frequencies</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/group-by" title="clojure.core/group-by
([f coll])
  Returns a map of the elements of coll keyed by the result of
  f on each element. The value at each key will be a vector of the
  corresponding elements, in the order they appeared in coll.">group-by</a> (clojure.set/) <a href="https://clojuredocs.org/clojure_core/clojure.set/index" title="clojure.set/index
([xrel ks])
  Returns a map of the distinct values of ks in the xrel mapped to a
  set of the maps in xrel with the corresponding values of ks.">index</a></code></td>
              </tr>
              <tr class="even">
                <td>Create sorted</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/sorted-map" title="clojure.core/sorted-map
([&amp; keyvals])
  keyval =&gt; key val
  Returns a new sorted map with supplied mappings.  If any keys are
  equal, they are handled as if by repeated uses of assoc.">sorted-map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sorted-map-by" title="clojure.core/sorted-map-by
([comparator &amp; keyvals])
  keyval =&gt; key val
  Returns a new sorted map with supplied mappings, using the supplied
  comparator.  If any keys are equal, they are handled as if by
  repeated uses of assoc.">sorted-map-by</a> (clojure.data.avl/) <a href="https://github.com/clojure/data.avl" title="clojure.data.avl/sorted-map
([&amp; keyvals])
  keyval =&gt; key val
  Returns a new AVL map with supplied mappings.">sorted-map</a> <a href="https://github.com/clojure/data.avl" title="clojure.data.avl/sorted-map-by
([comparator &amp; keyvals])
  keyval =&gt; key val
  Returns a new sorted map with supplied mappings, using the supplied
  comparator.">sorted-map-by</a> (flatland.ordered.map/) <a href="https://github.com/amalloy/ordered" title="flatland.ordered.map/ordered-map
([] [coll] [k v &amp; more])
  Return a map with the given keys and values, whose entries are
sorted in the order that keys are added. assoc'ing a key that is
already in an ordered map leaves its order unchanged. dissoc'ing a
key and then later assoc'ing it puts it at the end, as if it were
assoc'ed for the first time. Supports transient.">ordered-map</a> (clojure.data.priority-map/) <a href="https://github.com/clojure/data.priority-map" title="clojure.data.priority-map/priority-map
([&amp; keyvals])
  Usage: (priority-map key val key val ...)
  Returns a new priority map with optional supplied mappings.
  (priority-map) returns an empty priority map.">priority-map</a> (flatland.useful.map/) <a href="https://github.com/amalloy/useful/blob/master/src/flatland/useful/map.clj#L243-L245" title="flatland.useful.map/ordering-map
([key-order] [key-order default-comparator])
  Create an empty map with a custom comparator that puts the given keys first,
in the order
  specified. Other keys will be placed after the special keys, sorted by the
default-comparator.">ordering-map</a> (clojure.data.int-map/) <a href="https://github.com/clojure/data.int-map" title="clojure.data.int-map/int-map
([] [a b] [a b &amp; rest])
  Creates an integer map that can only have non-negative integers as keys.">int-map</a></code></td>
              </tr>
              <tr class="odd">
                <td>Examine</td>
                <td><code><code>(my-map k)</code> &rarr; <code>( <a href="https://clojuredocs.org/clojure_core/clojure.core/get" title="clojure.core/get
([map key] [map key not-found])
  Returns the value mapped to key, not-found or nil if key not present
  in associative collection, set, string, array, or ILookup instance.">get</a>  my-map k)</code> also <code>(:key my-map)</code> &rarr; <code>( <a href="https://clojuredocs.org/clojure_core/clojure.core/get" title="clojure.core/get
([map key] [map key not-found])
  Returns the value mapped to key, not-found or nil if key not present
  in associative collection, set, string, array, or ILookup instance.">get</a>  my-map :key)</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-in" title="clojure.core/get-in
([m ks] [m ks not-found])
  Returns the value in a nested associative structure,
  where ks is a sequence of keys. Returns nil if the key
  is not present, or the not-found value if supplied.">get-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/contains_q" title="clojure.core/contains?
([coll key])
  Returns true if key is present in the given collection, otherwise
  returns false.  Note that for numerically indexed collections like
  vectors and Java arrays, this tests if the numeric key is within the
  range of indexes. 'contains?' operates constant or logarithmic time;
  it will not perform a linear search for a value.  See also 'some'.">contains?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/find" title="clojure.core/find
([map key])
  Returns the map entry for key, or nil if key not present.">find</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keys" title="clojure.core/keys
([map])
  Returns a sequence of the map's keys, in the same order as (seq map).">keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vals" title="clojure.core/vals
([map])
  Returns a sequence of the map's values, in the same order as (seq map).">vals</a></code></td>
              </tr>
              <tr class="even">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/assoc" title="clojure.core/assoc
([map key val] [map key val &amp; kvs])
  assoc[iate]. When applied to a map, returns a new map of the
    same (hashed/sorted) type, that contains the mapping of key(s) to
    val(s). When applied to a vector, returns a new vector that
    contains val at index. Note - index must be &lt;= (count vector).">assoc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/assoc-in" title="clojure.core/assoc-in
([m [k &amp; ks] v])
  Associates a value in a nested associative structure, where ks is a
  sequence of keys and v is the new value and returns a new nested structure.
  If any levels do not exist, hash-maps will be created.">assoc-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dissoc" title="clojure.core/dissoc
([map] [map key] [map key &amp; ks])
  dissoc[iate]. Returns a new map of the same (hashed/sorted) type,
  that does not contain a mapping for key(s).">dissoc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/merge" title="clojure.core/merge
([&amp; maps])
  Returns a map that consists of the rest of the maps conj-ed onto
  the first.  If a key occurs in more than one map, the mapping from
  the latter (left-to-right) will be the mapping in the result.">merge</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/merge-with" title="clojure.core/merge-with
([f &amp; maps])
  Returns a map that consists of the rest of the maps conj-ed onto
  the first.  If a key occurs in more than one map, the mapping(s)
  from the latter (left-to-right) will be combined with the mapping in
  the result by calling (f val-in-result val-in-latter).">merge-with</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/select-keys" title="clojure.core/select-keys
([map keyseq])
  Returns a map containing only those entries in map whose key is in keys">select-keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update" title="clojure.core/update
([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z &amp; more])
  'Updates' a value in an associative structure, where k is a
  key and f is a function that will take the old value
  and any supplied args and return the new value, and returns a new
  structure.  If the key does not exist, nil is passed as the old value.">update</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update-in" title="clojure.core/update-in
([m ks f &amp; args])
  'Updates' a value in a nested associative structure, where ks is a
  sequence of keys and f is a function that will take the old value
  and any supplied args and return the new value, and returns a new
  nested structure.  If any levels do not exist, hash-maps will be
  created.">update-in</a> (clojure.set/) <a href="https://clojuredocs.org/clojure_core/clojure.set/rename-keys" title="clojure.set/rename-keys
([map kmap])
  Returns the map with the keys in kmap renamed to the vals in kmap">rename-keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/map-invert" title="clojure.set/map-invert
([m])
  Returns the map with the vals mapped to the keys.">map-invert</a> (1.11) (clojure.core/) <a href="https://clojuredocs.org/clojure_core/clojure.core/update-keys" title="clojure.core/update-keys
([m f])
  m f =&gt; {(f k) v ...}

  Given a map m and a function f of 1-argument, returns a new map whose
  keys are the result of applying f to the keys of m, mapped to the
  corresponding values of m.
  f must return a unique key for each key of m, else the behavior is undefined.">update-keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update-vals" title="clojure.core/update-vals
([m f])
  m f =&gt; {k (f v) ...}

  Given a map m and a function f of 1-argument, returns a new map where the keys
of m
  are mapped to result of applying f to the corresponding values of m.">update-vals</a> GitHub: <a href="https://github.com/weavejester/medley">Medley</a></code></td>
              </tr>
              <tr class="odd">
                <td>Ops</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/reduce-kv" title="clojure.core/reduce-kv
([f init coll])
  Reduces an associative collection. f should be a function of 3
  arguments. Returns the result of applying f to init, the first key
  and the first value in coll, then applying f to that result and the
  2nd key and value, etc. If coll contains no entries, returns init
  and f is not called. Note that reduce-kv is supported on vectors,
  where the keys will be the ordinals.">reduce-kv</a></code></td>
              </tr>
              <tr class="even">
                <td>Entry</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/key" title="clojure.core/key
([e])
  Returns the key of the map entry.">key</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/val" title="clojure.core/val
([e])
  Returns the value in the map entry.">val</a></code></td>
              </tr>
              <tr class="odd">
                <td>Sorted maps</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/rseq" title="clojure.core/rseq
([rev])
  Returns, in constant time, a seq of the items in rev (which
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil">rseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/subseq" title="clojure.core/subseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">subseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rsubseq" title="clojure.core/rsubseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a reverse seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">rsubseq</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Queues (conj at end, peek &amp; pop from beginning)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code>clojure.lang.PersistentQueue/EMPTY (no literal syntax or constructor fn)</code></td>
              </tr>
              <tr class="even">
                <td>Examine</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/peek" title="clojure.core/peek
([coll])
  For a list or queue, same as first, for a vector, same as, but much
  more efficient than, last. If the collection is empty, returns nil.">peek</a></code></td>
              </tr>
              <tr class="odd">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pop" title="clojure.core/pop
([coll])
  For a list or queue, returns a new list/queue without the first
  item, for a vector, returns a new vector without the last item. If
  the collection is empty, throws an exception.  Note - not the same
  as next/butlast.">pop</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
      </div><!-- /column -->
      <div class="column">
        <div class="section">
          <h3>Relations (set of maps, each with same keys, aka rels)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Rel algebra</td>
                <td><code>(clojure.set/) <a href="https://clojuredocs.org/clojure_core/clojure.set/join" title="clojure.set/join
([xrel yrel] [xrel yrel km])
  When passed 2 rels, returns the rel corresponding to the natural
  join. When passed an additional keymap, joins on the corresponding
  keys.">join</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/select" title="clojure.set/select
([pred xset])
  Returns a set of the elements for which pred is true">select</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/project" title="clojure.set/project
([xrel ks])
  Returns a rel of the elements of xrel with only the keys in ks">project</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/union" title="clojure.set/union
([] [s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the union of the input sets">union</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/difference" title="clojure.set/difference
([s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the first set without elements of the remaining sets">difference</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/intersection" title="clojure.set/intersection
([s1] [s1 s2] [s1 s2 &amp; sets])
  Return a set that is the intersection of the input sets">intersection</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/index" title="clojure.set/index
([xrel ks])
  Returns a map of the distinct values of ks in the xrel mapped to a
  set of the maps in xrel with the corresponding values of ks.">index</a> <a href="https://clojuredocs.org/clojure_core/clojure.set/rename" title="clojure.set/rename
([xrel kmap])
  Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in
kmap">rename</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Transients (<a href="https://clojure.org/reference/transients">clojure.org/reference/transients</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/transient" title="clojure.core/transient
([coll])
  Returns a new, transient version of the collection, in constant time.">transient</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/persistent%21" title="clojure.core/persistent!
([coll])
  Returns a new, persistent version of the transient collection, in
  constant time. The transient collection cannot be used after this
  call, any such use will throw an exception.">persistent!</a></code></td>
              </tr>
              <tr class="even">
                <td>Change</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/conj%21" title="clojure.core/conj!
([] [coll] [coll x])
  Adds x to the transient collection, and return coll. The 'addition'
  may happen at different 'places' depending on the concrete type.">conj!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pop%21" title="clojure.core/pop!
([coll])
  Removes the last item from a transient vector. If
  the collection is empty, throws an exception. Returns coll">pop!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/assoc%21" title="clojure.core/assoc!
([coll key val] [coll key val &amp; kvs])
  When applied to a transient map, adds mapping of key(s) to
  val(s). When applied to a transient vector, sets the val at index.
  Note - index must be &lt;= (count vector). Returns coll.">assoc!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dissoc%21" title="clojure.core/dissoc!
([map key] [map key &amp; ks])
  Returns a transient map that doesn't contain a mapping for key(s).">dissoc!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/disj%21" title="clojure.core/disj!
([set] [set key] [set key &amp; ks])
  disj[oin]. Returns a transient set of the same (hashed/sorted) type, that
  does not contain key(s).">disj!</a> Note: always use return value for later changes, never original!</code></td>
              </tr>
            </tbody>
          </table>
          <h3>Misc</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Compare</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/%3D" title="clojure.core/=
([x] [x y] [x y &amp; more])
  Equality. Returns true if x equals y, false if not. Same as
  Java x.equals(y) except it also works for nil, and compares
  numbers and collections in a type-independent manner.  Clojure's immutable
data
  structures define equals() (and thus =) as a value, not an identity,
  comparison.">=</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/identical_q" title="clojure.core/identical?
([x y])
  Tests if 2 arguments are the same object">identical?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/not%3D" title="clojure.core/not=
([x] [x y] [x y &amp; more])
  Same as (not (= obj1 obj2))">not=</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/not" title="clojure.core/not
([x])
  Returns true if x is logical false, false otherwise.">not</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compare" title="clojure.core/compare
([x y])
  Comparator. Returns a negative number, zero, or a positive number
  when x is logically 'less than', 'equal to', or 'greater than'
  y. Same as Java x.compareTo(y) except it also works for nil, and
  compares numbers and collections in a type-independent manner. x
  must implement Comparable">compare</a> <a href="https://clojuredocs.org/clojure_core/clojure.data/diff" title="clojure.data/diff
([a b])
  Recursively compares a and b, returning a tuple of
  [things-only-in-a things-only-in-b things-in-both].
  Comparison rules:

  * For equal a and b, return [nil nil a].
  * Maps are subdiffed where keys match and values differ.
  * Sets are never subdiffed.
  * All sequential things are treated as associative collections
    by their indexes, with results returned as vectors.
  * Everything else (including strings!) is treated as
    an atom and compared for equality.">clojure.data/diff</a></code></td>
              </tr>
              <tr class="even">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/true_q" title="clojure.core/true?
([x])
  Returns true if x is the value true, false otherwise.">true?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/false_q" title="clojure.core/false?
([x])
  Returns true if x is the value false, false otherwise.">false?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/instance_q" title="clojure.core/instance?
([c x])
  Evaluates x and tests if it is an instance of the class
    c. Returns true or false">instance?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nil_q" title="clojure.core/nil?
([x])
  Returns true if x is nil, false otherwise.">nil?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some_q" title="clojure.core/some?
([x])
  Returns true if x is not nil, false otherwise.">some?</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Sequences</h2>
          <h3>Creating a Lazy Seq</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>From collection</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/seq" title="clojure.core/seq
([coll])
  Returns a seq on the collection. If the collection is
    empty, returns nil.  (seq nil) returns nil. seq also works on
    Strings, native Java arrays (of reference types) and any objects
    that implement Iterable. Note that seqs cache values, thus seq
    should not be used on any Iterable whose iterator repeatedly
    returns the same mutable object.">seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vals" title="clojure.core/vals
([map])
  Returns a sequence of the map's values, in the same order as (seq map).">vals</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keys" title="clojure.core/keys
([map])
  Returns a sequence of the map's keys, in the same order as (seq map).">keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rseq" title="clojure.core/rseq
([rev])
  Returns, in constant time, a seq of the items in rev (which
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil">rseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/subseq" title="clojure.core/subseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">subseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rsubseq" title="clojure.core/rsubseq
([sc test key] [sc start-test start-key end-test end-key])
  sc must be a sorted collection, test(s) one of &lt;, &lt;=, &gt; or
  &gt;=. Returns a reverse seq of those entries with keys ek for
  which (test (.. sc comparator (compare ek key)) 0) is true">rsubseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sequence" title="clojure.core/sequence
([coll] [xform coll] [xform coll &amp; colls])
  Coerces coll to a (possibly empty) sequence, if it is not already
  one. Will not force a lazy seq. (sequence nil) yields (), When a
  transducer is supplied, returns a lazy sequence of applications of
  the transform to the items in coll(s), i.e. to the set of first
  items of each coll, followed by the set of second
  items in each coll, until any one of the colls is exhausted.  Any
  remaining items in other colls are ignored. The transform should accept
  number-of-colls arguments">sequence</a></code></td>
              </tr>
              <tr class="even">
                <td>From producer fn</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/lazy-seq" title="clojure.core/lazy-seq
([&amp; body])
Macro
  Takes a body of expressions that returns an ISeq or nil, and yields
  a Seqable object that will invoke the body only the first time seq
  is called, and will cache the result and return it on all subsequent
  seq calls. See also - realized?">lazy-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/repeatedly" title="clojure.core/repeatedly
([f] [n f])
  Takes a function of no args, presumably with side effects, and
  returns an infinite (or length n if supplied) lazy sequence of calls
  to it">repeatedly</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/iterate" title="clojure.core/iterate
([f x])
  Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of
side-effects">iterate</a> (1.11) <a href="https://clojuredocs.org/clojure_core/clojure.core/iteration" title="clojure.core/iteration
([step &amp; {:keys [somef vf kf initk], :or {vf identity, kf identity, somef some?,
initk nil}}])
  Creates a seqable/reducible via repeated calls to step,
  a function of some (continuation token) 'k'. The first call to step
  will be passed initk, returning 'ret'. Iff (somef ret) is true,
  (vf ret) will be included in the iteration, else iteration will
  terminate and vf/kf will not be called. If (kf ret) is non-nil it
  will be passed to the next step call, else iteration will terminate.

  This can be used e.g. to consume APIs that return paginated or batched data.

   step - (possibly impure) fn of 'k' -&gt; 'ret'

   :somef - fn of 'ret' -&gt; logical true/false, default 'some?'
   :vf - fn of 'ret' -&gt; 'v', a value produced by the iteration, default
'identity'
   :kf - fn of 'ret' -&gt; 'next-k' or nil (signaling 'do not continue'), default
'identity'
   :initk - the first value passed to step, default 'nil'

  It is presumed that step with non-initk is unreproducible/non-idempotent.
  If step with initk is unreproducible it is on the consumer to not consume
twice.">iteration</a></code></td>
              </tr>
              <tr class="odd">
                <td>From constant</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/repeat" title="clojure.core/repeat
([x] [n x])
  Returns a lazy (infinite!, or length n if supplied) sequence of xs.">repeat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/range" title="clojure.core/range
([] [end] [start end] [start end step])
  Returns a lazy seq of nums from start (inclusive) to end
  (exclusive), by step, where start defaults to 0, step to 1, and end to
  infinity. When step is equal to 0, returns an infinite sequence of
  start. When start is equal to end, returns empty list.">range</a></code></td>
              </tr>
              <tr class="even">
                <td>From other</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/file-seq" title="clojure.core/file-seq
([dir])
  A tree seq on java.io.Files">file-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/line-seq" title="clojure.core/line-seq
([rdr])
  Returns the lines of text from rdr as a lazy sequence of strings.
  rdr must implement java.io.BufferedReader.">line-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/resultset-seq" title="clojure.core/resultset-seq
([rs])
  Creates and returns a lazy sequence of structmaps corresponding to
  the rows in the java.sql.ResultSet rs">resultset-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/re-seq" title="clojure.core/re-seq
([re s])
  Returns a lazy sequence of successive matches of pattern in string,
  using java.util.regex.Matcher.find(), each such match processed with
  re-groups.">re-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/tree-seq" title="clojure.core/tree-seq
([branch? children root])
  Returns a lazy sequence of the nodes in a tree, via a depth-first walk.
   branch? must be a fn of one arg that returns true if passed a node
   that can have children (but may not).  children must be a fn of one
   arg that returns a sequence of the children. Will only be called on
   nodes for which branch? returns true. Root is the root node of the
  tree.">tree-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/xml-seq" title="clojure.core/xml-seq
([root])
  A tree seq on the xml elements as per xml/parse">xml-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/iterator-seq" title="clojure.core/iterator-seq
([iter])
  Returns a seq on a java.util.Iterator. Note that most collections
  providing iterators implement Iterable and thus support seq directly.
  Seqs cache values, thus iterator-seq should not be used on any
  iterator that repeatedly returns the same mutable object.">iterator-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/enumeration-seq" title="clojure.core/enumeration-seq
([e])
  Returns a seq on a java.util.Enumeration">enumeration-seq</a></code></td>
              </tr>
              <tr class="odd">
                <td>From seq</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/keep" title="clojure.core/keep
([f] [f coll])
  Returns a lazy sequence of the non-nil results of (f item). Note,
  this means false return values will be included.  f must be free of
  side-effects.  Returns a transducer when no collection is provided.">keep</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keep-indexed" title="clojure.core/keep-indexed
([f] [f coll])
  Returns a lazy sequence of the non-nil results of (f index item). Note,
  this means false return values will be included.  f must be free of
  side-effects.  Returns a stateful transducer when no collection is
  provided.">keep-indexed</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Seq in, Seq out</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Get shorter</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/distinct" title="clojure.core/distinct
([] [coll])
  Returns a lazy sequence of the elements of coll with duplicates removed.
  Returns a stateful transducer when no collection is provided.">distinct</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filter" title="clojure.core/filter
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">filter</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove" title="clojure.core/remove
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical false. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">remove</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take-nth" title="clojure.core/take-nth
([n] [n coll])
  Returns a lazy seq of every nth item in coll.  Returns a stateful
  transducer when no collection is provided.">take-nth</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dedupe" title="clojure.core/dedupe
([] [coll])
  Returns a lazy sequence removing consecutive duplicates in coll.
  Returns a transducer when no collection is provided.">dedupe</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/random-sample" title="clojure.core/random-sample
([prob] [prob coll])
  Returns items from coll with random probability of prob (0.0 -
  1.0).  Returns a transducer when no collection is provided.">random-sample</a></code></td>
              </tr>
              <tr class="even">
                <td>Get longer</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/cons" title="clojure.core/cons
([x seq])
  Returns a new seq where x is the first element and seq is
    the rest.">cons</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/concat" title="clojure.core/concat
([] [x] [x y] [x y &amp; zs])
  Returns a lazy seq representing the concatenation of the elements in the
supplied colls.">concat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/lazy-cat" title="clojure.core/lazy-cat
([&amp; colls])
Macro
  Expands to code which yields a lazy sequence of the concatenation
  of the supplied colls.  Each coll expr is not evaluated until it is
  needed.

  (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))">lazy-cat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mapcat" title="clojure.core/mapcat
([f] [f &amp; colls])
  Returns the result of applying concat to the result of applying map
  to f and colls.  Thus function f should return a collection. Returns
  a transducer when no collections are provided">mapcat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cycle" title="clojure.core/cycle
([coll])
  Returns a lazy (infinite!) sequence of repetitions of the items in coll.">cycle</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/interleave" title="clojure.core/interleave
([] [c1] [c1 c2] [c1 c2 &amp; colls])
  Returns a lazy seq of the first item in each coll, then the second etc.">interleave</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/interpose" title="clojure.core/interpose
([sep] [sep coll])
  Returns a lazy seq of the elements of coll separated by sep.
  Returns a stateful transducer when no collection is provided.">interpose</a></code></td>
              </tr>
              <tr class="odd">
                <td>Tail-items</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/rest" title="clojure.core/rest
([coll])
  Returns a possibly empty seq of the items after the first. Calls seq on its
  argument.">rest</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nthrest" title="clojure.core/nthrest
([coll n])
  Returns the nth rest of coll, coll when n is 0.">nthrest</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/next" title="clojure.core/next
([coll])
  Returns a seq of the items after the first. Calls seq on its
  argument.  If there are no more items, returns nil.">next</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/fnext" title="clojure.core/fnext
([x])
  Same as (first (next x))">fnext</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nnext" title="clojure.core/nnext
([x])
  Same as (next (next x))">nnext</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/drop" title="clojure.core/drop
([n] [n coll])
  Returns a lazy sequence of all but the first n items in coll.
  Returns a stateful transducer when no collection is provided.">drop</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/drop-while" title="clojure.core/drop-while
([pred] [pred coll])
  Returns a lazy sequence of the items in coll starting from the
  first item for which (pred item) returns logical false.  Returns a
  stateful transducer when no collection is provided.">drop-while</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take-last" title="clojure.core/take-last
([n coll])
  Returns a seq of the last n items in coll.  Depending on the type
  of coll may be no better than linear time.  For vectors, see also subvec.">take-last</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a></code></td>
              </tr>
              <tr class="even">
                <td>Head-items</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/take" title="clojure.core/take
([n] [n coll])
  Returns a lazy sequence of the first n items in coll, or all items if
  there are fewer than n.  Returns a stateful transducer when
  no collection is provided.">take</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take-while" title="clojure.core/take-while
([pred] [pred coll])
  Returns a lazy sequence of successive items from coll while
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">take-while</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/butlast" title="clojure.core/butlast
([coll])
  Return a seq of all but the last item in coll, in linear time">butlast</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/drop-last" title="clojure.core/drop-last
([coll] [n coll])
  Return a lazy sequence of all but the last n (default 1) items in coll">drop-last</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a></code></td>
              </tr>
              <tr class="odd">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/conj" title="clojure.core/conj
([] [coll] [coll x] [coll x &amp; xs])
  conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).
    (conj coll) returns coll. (conj) returns [].
    The 'addition' may happen at different 'places' depending
    on the concrete type.">conj</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/concat" title="clojure.core/concat
([] [x] [x y] [x y &amp; zs])
  Returns a lazy seq representing the concatenation of the elements in the
supplied colls.">concat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/distinct" title="clojure.core/distinct
([] [coll])
  Returns a lazy sequence of the elements of coll with duplicates removed.
  Returns a stateful transducer when no collection is provided.">distinct</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/flatten" title="clojure.core/flatten
([x])
  Takes any nested combination of sequential things (lists, vectors,
  etc.) and returns their contents as a single, flat lazy sequence.
  (flatten nil) returns an empty sequence.">flatten</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/group-by" title="clojure.core/group-by
([f coll])
  Returns a map of the elements of coll keyed by the result of
  f on each element. The value at each key will be a vector of the
  corresponding elements, in the order they appeared in coll.">group-by</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partition" title="clojure.core/partition
([n coll] [n step coll] [n step pad coll])
  Returns a lazy sequence of lists of n items each, at offsets step
  apart. If step is not supplied, defaults to n, i.e. the partitions
  do not overlap. If a pad collection is supplied, use its elements as
  necessary to complete last partition upto n items. In case there are
  not enough padding elements, return a partition with less than n items.">partition</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partition-all" title="clojure.core/partition-all
([n] [n coll] [n step coll])
  Returns a lazy sequence of lists like partition, but may include
  partitions with fewer than n items at the end.  Returns a stateful
  transducer when no collection is provided.">partition-all</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partition-by" title="clojure.core/partition-by
([f] [f coll])
  Applies f to each value in coll, splitting it each time f returns a
   new value.  Returns a lazy seq of partitions.  Returns a stateful
   transducer when no collection is provided.">partition-by</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/split-at" title="clojure.core/split-at
([n coll])
  Returns a vector of [(take n coll) (drop n coll)]">split-at</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/split-with" title="clojure.core/split-with
([pred coll])
  Returns a vector of [(take-while pred coll) (drop-while pred coll)]">split-with</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filter" title="clojure.core/filter
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">filter</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove" title="clojure.core/remove
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical false. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">remove</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/replace" title="clojure.core/replace
([smap] [smap coll])
  Given a map of replacement pairs and a vector/collection, returns a
  vector/seq with any elements = a key in smap replaced with the
  corresponding val in smap.  Returns a transducer when no collection
  is provided.">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/shuffle" title="clojure.core/shuffle
([coll])
  Return a random permutation of coll">shuffle</a></code></td>
              </tr>
              <tr class="even">
                <td>Rearrange</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/reverse" title="clojure.core/reverse
([coll])
  Returns a seq of the items in coll in reverse order. Not lazy.">reverse</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sort" title="clojure.core/sort
([coll] [comp coll])
  Returns a sorted sequence of the items in coll. If no comparator is
  supplied, uses compare.  comparator must implement
  java.util.Comparator.  Guaranteed to be stable: equal elements will
  not be reordered.  If coll is a Java array, it will be modified.  To
  avoid this, sort a copy of the array.">sort</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sort-by" title="clojure.core/sort-by
([keyfn coll] [keyfn comp coll])
  Returns a sorted sequence of the items in coll, where the sort
  order is determined by comparing (keyfn item).  If no comparator is
  supplied, uses compare.  comparator must implement
  java.util.Comparator.  Guaranteed to be stable: equal elements will
  not be reordered.  If coll is a Java array, it will be modified.  To
  avoid this, sort a copy of the array.">sort-by</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compare" title="clojure.core/compare
([x y])
  Comparator. Returns a negative number, zero, or a positive number
  when x is logically 'less than', 'equal to', or 'greater than'
  y. Same as Java x.compareTo(y) except it also works for nil, and
  compares numbers and collections in a type-independent manner. x
  must implement Comparable">compare</a></code></td>
              </tr>
              <tr class="odd">
                <td>Process items</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/map" title="clojure.core/map
([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 &amp; colls])
  Returns a lazy sequence consisting of the result of applying f to
  the set of first items of each coll, followed by applying f to the
  set of second items in each coll, until any one of the colls is
  exhausted.  Any remaining items in other colls are ignored. Function
  f should accept number-of-colls arguments. Returns a transducer when
  no collection is provided.">map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pmap" title="clojure.core/pmap
([f coll] [f coll &amp; colls])
  Like map, except f is applied in parallel. Semi-lazy in that the
  parallel computation stays ahead of the consumption, but doesn't
  realize the entire result unless required. Only useful for
  computationally intensive functions where the time of f dominates
  the coordination overhead.">pmap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/map-indexed" title="clojure.core/map-indexed
([f] [f coll])
  Returns a lazy sequence consisting of the result of applying f to 0
  and the first item of coll, followed by applying f to 1 and the second
  item in coll, etc, until coll is exhausted. Thus function f should
  accept 2 arguments, index and item. Returns a stateful transducer when
  no collection is provided.">map-indexed</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mapcat" title="clojure.core/mapcat
([f] [f &amp; colls])
  Returns the result of applying concat to the result of applying map
  to f and colls.  Thus function f should return a collection. Returns
  a transducer when no collections are provided">mapcat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/replace" title="clojure.core/replace
([smap] [smap coll])
  Given a map of replacement pairs and a vector/collection, returns a
  vector/seq with any elements = a key in smap replaced with the
  corresponding val in smap.  Returns a transducer when no collection
  is provided.">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/seque" title="clojure.core/seque
([s] [n-or-q s])
  Creates a queued seq on another (presumably lazy) seq s. The queued
  seq will produce a concrete seq in the background, and can get up to
  n items ahead of the consumer. n-or-q can be an integer n buffer
  size, or an instance of java.util.concurrent BlockingQueue. Note
  that reading from a seque can block if the reader gets ahead of the
  producer.">seque</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Using a Seq</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Extract item</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/first" title="clojure.core/first
([coll])
  Returns the first item in the collection. Calls seq on its
    argument. If coll is nil, returns nil.">first</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/second" title="clojure.core/second
([x])
  Same as (first (next x))">second</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/last" title="clojure.core/last
([coll])
  Return the last item in coll, in linear time">last</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rest" title="clojure.core/rest
([coll])
  Returns a possibly empty seq of the items after the first. Calls seq on its
  argument.">rest</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/next" title="clojure.core/next
([coll])
  Returns a seq of the items after the first. Calls seq on its
  argument.  If there are no more items, returns nil.">next</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ffirst" title="clojure.core/ffirst
([x])
  Same as (first (first x))">ffirst</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nfirst" title="clojure.core/nfirst
([x])
  Same as (next (first x))">nfirst</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/fnext" title="clojure.core/fnext
([x])
  Same as (first (next x))">fnext</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nnext" title="clojure.core/nnext
([x])
  Same as (next (next x))">nnext</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nth" title="clojure.core/nth
([coll index] [coll index not-found])
  Returns the value at the index. get returns nil if index out of
  bounds, nth throws an exception unless not-found is supplied.  nth
  also works for strings, Java arrays, regex Matchers and Lists, and,
  in O(n) time, for sequences.">nth</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nthnext" title="clojure.core/nthnext
([coll n])
  Returns the nth next of coll, (seq coll) when n is 0.">nthnext</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rand-nth" title="clojure.core/rand-nth
([coll])
  Return a random element of the (sequential) collection. Will have
  the same performance characteristics as nth for the given
  collection.">rand-nth</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-first" title="clojure.core/when-first
([bindings &amp; body])
Macro
  bindings =&gt; x xs

  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is
evaluated only once">when-first</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/max-key" title="clojure.core/max-key
([k x] [k x y] [k x y &amp; more])
  Returns the x for which (k x), a number, is greatest.

  If there are multiple such xs, the last one is returned.">max-key</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/min-key" title="clojure.core/min-key
([k x] [k x y] [k x y &amp; more])
  Returns the x for which (k x), a number, is least.

  If there are multiple such xs, the last one is returned.">min-key</a></code></td>
              </tr>
              <tr class="even">
                <td>Construct coll</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/zipmap" title="clojure.core/zipmap
([keys vals])
  Returns a map with the keys mapped to the corresponding vals.">zipmap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/into" title="clojure.core/into
([] [to] [to from] [to xform from])
  Returns a new coll consisting of to-coll with all of the items of
  from-coll conjoined. A transducer may be supplied.">into</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reduce" title="clojure.core/reduce
([f coll] [f val coll])
  f should be a function of 2 arguments. If val is not supplied,
  returns the result of applying f to the first 2 items in coll, then
  applying f to that result and the 3rd item, etc. If coll contains no
  items, f must accept no arguments as well, and reduce returns the
  result of calling f with no arguments.  If coll has only 1 item, it
  is returned and f is not called.  If val is supplied, returns the
  result of applying f to val and the first item in coll, then
  applying f to that result and the 2nd item, etc. If coll contains no
  items, returns val and f is not called.">reduce</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reductions" title="clojure.core/reductions
([f coll] [f init coll])
  Returns a lazy seq of the intermediate values of the reduction (as
  per reduce) of coll by f, starting with init.">reductions</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set" title="clojure.core/set
([coll])
  Returns a set of the distinct elements of coll.">set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vec" title="clojure.core/vec
([coll])
  Creates a new vector containing the contents of coll. Java arrays
  will be aliased and should not be modified.">vec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/into-array" title="clojure.core/into-array
([aseq] [type aseq])
  Returns an array with components set to the values in aseq. The array's
  component type is type if provided, or the type of the first value in
  aseq if present, or Object. All values in aseq must be compatible with
  the component type. Class objects for the primitive types can be obtained
  using, e.g., Integer/TYPE.">into-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/to-array-2d" title="clojure.core/to-array-2d
([coll])
  Returns a (potentially-ragged) 2-dimensional array of Objects
  containing the contents of coll, which can be any Collection of any
  Collection.">to-array-2d</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mapv" title="clojure.core/mapv
([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 &amp; colls])
  Returns a vector consisting of the result of applying f to the
  set of first items of each coll, followed by applying f to the set
  of second items in each coll, until any one of the colls is
  exhausted.  Any remaining items in other colls are ignored. Function
  f should accept number-of-colls arguments.">mapv</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filterv" title="clojure.core/filterv
([pred coll])
  Returns a vector of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.">filterv</a></code></td>
              </tr>
              <tr class="odd">
                <td>Pass to fn</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/apply" title="clojure.core/apply
([f args] [f x args] [f x y args] [f x y z args] [f a b c d &amp; args])
  Applies fn f to the argument list formed by prepending intervening arguments
to args.">apply</a></code></td>
              </tr>
              <tr class="even">
                <td>Search</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/some" title="clojure.core/some
([pred coll])
  Returns the first logical true value of (pred x) for any x in coll,
  else nil.  One common idiom is to use a set as pred, for example
  this will return :fred if :fred is in the sequence, otherwise nil:
  (some #{:fred} coll)">some</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filter" title="clojure.core/filter
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">filter</a></code></td>
              </tr>
              <tr class="odd">
                <td>Force evaluation</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/doseq" title="clojure.core/doseq
([seq-exprs &amp; body])
Macro
  Repeatedly executes body (presumably for side-effects) with
  bindings and filtering as provided by &quot;for&quot;.  Does not retain
  the head of the sequence. Returns nil.">doseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dorun" title="clojure.core/dorun
([coll] [n coll])
  When lazy sequences are produced via functions that have side
  effects, any effects other than those needed to produce the first
  element in the seq do not occur until the seq is consumed. dorun can
  be used to force any effects. Walks through the successive nexts of
  the seq, does not retain the head and returns nil.">dorun</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doall" title="clojure.core/doall
([coll] [n coll])
  When lazy sequences are produced via functions that have side
  effects, any effects other than those needed to produce the first
  element in the seq do not occur until the seq is consumed. doall can
  be used to force any effects. Walks through the successive nexts of
  the seq, retains the head and returns it, thus causing the entire
  seq to reside in memory at one time.">doall</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/run%21" title="clojure.core/run!
([proc coll])
  Runs the supplied procedure (via reduce), for purposes of side
  effects, on successive items in the collection. Returns nil">run!</a></code></td>
              </tr>
              <tr class="even">
                <td>Check for forced</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/realized_q" title="clojure.core/realized?
([x])
  Returns true if a value has been produced for a promise, delay, future or lazy
sequence.">realized?</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Transducers (<a href="https://clojure.org/reference/transducers">clojure.org/reference/transducers</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Off the shelf</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/map" title="clojure.core/map
([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 &amp; colls])
  Returns a lazy sequence consisting of the result of applying f to
  the set of first items of each coll, followed by applying f to the
  set of second items in each coll, until any one of the colls is
  exhausted.  Any remaining items in other colls are ignored. Function
  f should accept number-of-colls arguments. Returns a transducer when
  no collection is provided.">map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/mapcat" title="clojure.core/mapcat
([f] [f &amp; colls])
  Returns the result of applying concat to the result of applying map
  to f and colls.  Thus function f should return a collection. Returns
  a transducer when no collections are provided">mapcat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/filter" title="clojure.core/filter
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">filter</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove" title="clojure.core/remove
([pred] [pred coll])
  Returns a lazy sequence of the items in coll for which
  (pred item) returns logical false. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">remove</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take" title="clojure.core/take
([n] [n coll])
  Returns a lazy sequence of the first n items in coll, or all items if
  there are fewer than n.  Returns a stateful transducer when
  no collection is provided.">take</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take-while" title="clojure.core/take-while
([pred] [pred coll])
  Returns a lazy sequence of successive items from coll while
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided.">take-while</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/take-nth" title="clojure.core/take-nth
([n] [n coll])
  Returns a lazy seq of every nth item in coll.  Returns a stateful
  transducer when no collection is provided.">take-nth</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/drop" title="clojure.core/drop
([n] [n coll])
  Returns a lazy sequence of all but the first n items in coll.
  Returns a stateful transducer when no collection is provided.">drop</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/drop-while" title="clojure.core/drop-while
([pred] [pred coll])
  Returns a lazy sequence of the items in coll starting from the
  first item for which (pred item) returns logical false.  Returns a
  stateful transducer when no collection is provided.">drop-while</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/replace" title="clojure.core/replace
([smap] [smap coll])
  Given a map of replacement pairs and a vector/collection, returns a
  vector/seq with any elements = a key in smap replaced with the
  corresponding val in smap.  Returns a transducer when no collection
  is provided.">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partition-by" title="clojure.core/partition-by
([f] [f coll])
  Applies f to each value in coll, splitting it each time f returns a
   new value.  Returns a lazy seq of partitions.  Returns a stateful
   transducer when no collection is provided.">partition-by</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partition-all" title="clojure.core/partition-all
([n] [n coll] [n step coll])
  Returns a lazy sequence of lists like partition, but may include
  partitions with fewer than n items at the end.  Returns a stateful
  transducer when no collection is provided.">partition-all</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keep" title="clojure.core/keep
([f] [f coll])
  Returns a lazy sequence of the non-nil results of (f item). Note,
  this means false return values will be included.  f must be free of
  side-effects.  Returns a transducer when no collection is provided.">keep</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/keep-indexed" title="clojure.core/keep-indexed
([f] [f coll])
  Returns a lazy sequence of the non-nil results of (f index item). Note,
  this means false return values will be included.  f must be free of
  side-effects.  Returns a stateful transducer when no collection is
  provided.">keep-indexed</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/map-indexed" title="clojure.core/map-indexed
([f] [f coll])
  Returns a lazy sequence consisting of the result of applying f to 0
  and the first item of coll, followed by applying f to 1 and the second
  item in coll, etc, until coll is exhausted. Thus function f should
  accept 2 arguments, index and item. Returns a stateful transducer when
  no collection is provided.">map-indexed</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/distinct" title="clojure.core/distinct
([] [coll])
  Returns a lazy sequence of the elements of coll with duplicates removed.
  Returns a stateful transducer when no collection is provided.">distinct</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/interpose" title="clojure.core/interpose
([sep] [sep coll])
  Returns a lazy seq of the elements of coll separated by sep.
  Returns a stateful transducer when no collection is provided.">interpose</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cat" title="clojure.core/cat
([rf])
  A transducer which concatenates the contents of each input, which must be a
  collection, into the reduction.">cat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dedupe" title="clojure.core/dedupe
([] [coll])
  Returns a lazy sequence removing consecutive duplicates in coll.
  Returns a transducer when no collection is provided.">dedupe</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/random-sample" title="clojure.core/random-sample
([prob] [prob coll])
  Returns items from coll with random probability of prob (0.0 -
  1.0).  Returns a transducer when no collection is provided.">random-sample</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/halt-when" title="clojure.core/halt-when
([pred] [pred retf])
  Returns a transducer that ends transduction when pred returns true
  for an input. When retf is supplied it must be a fn of 2 arguments -
  it will be passed the (completed) result so far and the input that
  triggered the predicate, and its return value (if it does not throw
  an exception) will be the return value of the transducer. If retf
  is not supplied, the input that triggered the predicate will be
  returned. If the predicate never returns true the transduction is
  unaffected.">halt-when</a></code></td>
              </tr>
              <tr class="even">
                <td>Create your own</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/completing" title="clojure.core/completing
([f] [f cf])
  Takes a reducing function f of 2 args and returns a fn suitable for
  transduce by adding an arity-1 signature that calls cf (default -
  identity) on the result argument.">completing</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ensure-reduced" title="clojure.core/ensure-reduced
([x])
  If x is already reduced?, returns it, else returns (reduced x)">ensure-reduced</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/unreduced" title="clojure.core/unreduced
([x])
  If x is reduced?, returns (deref x), else returns x">unreduced</a> See also section Concurrency/Volatiles</code></td>
              </tr>
              <tr class="odd">
                <td>Use</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/into" title="clojure.core/into
([] [to] [to from] [to xform from])
  Returns a new coll consisting of to-coll with all of the items of
  from-coll conjoined. A transducer may be supplied.">into</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sequence" title="clojure.core/sequence
([coll] [xform coll] [xform coll &amp; colls])
  Coerces coll to a (possibly empty) sequence, if it is not already
  one. Will not force a lazy seq. (sequence nil) yields (), When a
  transducer is supplied, returns a lazy sequence of applications of
  the transform to the items in coll(s), i.e. to the set of first
  items of each coll, followed by the set of second
  items in each coll, until any one of the colls is exhausted.  Any
  remaining items in other colls are ignored. The transform should accept
  number-of-colls arguments">sequence</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/transduce" title="clojure.core/transduce
([xform f coll] [xform f init coll])
  reduce with a transformation of f (xf). If init is not
  supplied, (f) will be called to produce it. f should be a reducing
  step function that accepts both 1 and 2 arguments, if it accepts
  only 2 you can add the arity-1 with 'completing'. Returns the result
  of applying (the transformed) xf to init and the first item in coll,
  then applying xf to that result and the 2nd item, etc. If coll
  contains no items, returns init and f is not called. Note that
  certain transforms may inject or skip items.">transduce</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/eduction" title="clojure.core/eduction
([xform* coll])
  Returns a reducible/iterable application of the transducers
  to the items in coll. Transducers are applied in order as if
  combined with comp. Note that these applications will be
  performed every time reduce/iterator is called.">eduction</a></code></td>
              </tr>
              <tr class="even">
                <td>Early termination</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/reduced" title="clojure.core/reduced
([x])
  Wraps x in a way such that a reduce will terminate with the value x">reduced</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reduced_q" title="clojure.core/reduced?
([x])
  Returns true if x is the result of a call to reduced">reduced?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/deref" title="clojure.core/deref
([ref] [ref timeout-ms timeout-val])
  Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a
transaction,
  returns the in-transaction-value of ref, else returns the
  most-recently-committed value of ref. When applied to a var, agent
  or atom, returns its current state. When applied to a delay, forces
  it if not already forced. When applied to a future, will block if
  computation not complete. When applied to a promise, will block
  until a value is delivered.  The variant taking a timeout can be
  used for blocking references (futures and promises), and will return
  timeout-val if the timeout (in milliseconds) is reached before a
  value is available. See also - realized?.">deref</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Spec (<a href="https://clojure.org/about/spec">rationale</a>, <a href="https://clojure.org/guides/spec">guide</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Operations</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/valid_q" title="clojure.spec.alpha/valid?
([spec x] [spec x form])
  Helper function that returns true when x is valid for spec.">valid?</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/conform" title="clojure.spec.alpha/conform
([spec x])
  Given a spec and a value, returns :clojure.spec.alpha/invalid
	if value does not match spec, else the (possibly destructured) value.">conform</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/unform" title="clojure.spec.alpha/unform
([spec x])
  Given a spec and a value created by or compliant with a call to
  'conform' with the same spec, returns a value with all conform
  destructuring undone.">unform</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/explain" title="clojure.spec.alpha/explain
([spec x])
  Given a spec and a value that fails to conform, prints an explanation to
*out*.">explain</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/explain-data" title="clojure.spec.alpha/explain-data
([spec x])
  Given a spec and a value x which ought to conform, returns nil if x
  conforms, else a map with at least the key ::problems whose value is
  a collection of problem-maps, where problem-map has at least :path :pred and
:val
  keys describing the predicate and the value that failed at that
  path.">explain-data</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/explain-str" title="clojure.spec.alpha/explain-str
([spec x])
  Given a spec and a value that fails to conform, returns an explanation as a
string.">explain-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/explain-out" title="clojure.spec.alpha/explain-out
([ed])
  Prints explanation data (per 'explain-data') to *out* using the printer in
*explain-out*,
   by default explain-printer.">explain-out</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/form" title="clojure.spec.alpha/form
([spec])
  returns the spec as data">form</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/describe" title="clojure.spec.alpha/describe
([spec])
  returns an abbreviated description of the spec as data">describe</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/assert" title="clojure.spec.alpha/assert
([spec x])
Macro
  spec-checking assert expression. Returns x if x is valid? according
to spec, else throws an ex-info with explain-data plus ::failure of
:assertion-failed.

Can be disabled at either compile time or runtime:

If *compile-asserts* is false at compile time, compiles to x. Defaults
to value of 'clojure.spec.compile-asserts' system property, or true if
not set.

If (check-asserts?) is false at runtime, always returns x. Defaults to
value of 'clojure.spec.check-asserts' system property, or false if not
set. You can toggle check-asserts? with (check-asserts bool).">assert</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/check-asserts" title="clojure.spec.alpha/check-asserts
([flag])
  Enable or disable spec asserts that have been compiled
with '*compile-asserts*' true.  See 'assert'.

Initially set to boolean value of clojure.spec.check-asserts
system property. Defaults to false.">check-asserts</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/check-asserts_q" title="clojure.spec.alpha/check-asserts?
([])
  Returns the value set by check-asserts.">check-asserts?</a></code></td>
              </tr>
              <tr class="even">
                <td>Generator ops</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/gen" title="clojure.spec.alpha/gen
([spec] [spec overrides])
  Given a spec, returns the generator for it, or throws if none can
  be constructed. Optionally an overrides map can be provided which
  should map spec names or paths (vectors of keywords) to no-arg
  generator-creating fns. These will be used instead of the generators at those
  names/paths. Note that parent generator (in the spec or overrides
  map) will supersede those of any subtrees. A generator for a regex
  op must always return a sequential collection (i.e. a generator for
  s/? should return either an empty sequence/vector or a
  sequence/vector with one item in it)">gen</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/exercise" title="clojure.spec.alpha/exercise
([spec] [spec n] [spec n overrides])
  generates a number (default 10) of values compatible with spec and maps
conform over them,
  returning a sequence of [val conformed-val] tuples. Optionally takes
  a generator overrides map as per gen">exercise</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/exercise-fn" title="clojure.spec.alpha/exercise-fn
([sym] [sym n] [sym-or-f n fspec])
  exercises the fn named by sym (a symbol) by applying it to
  n (default 10) generated samples of its args spec. When fspec is
  supplied its arg spec is used, and sym-or-f can be a fn.  Returns a
  sequence of tuples of [args ret].">exercise-fn</a></code></td>
              </tr>
              <tr class="odd">
                <td>Defn. &amp; registry</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/def" title="clojure.spec.alpha/def
([k spec-form])
Macro
  Given a namespace-qualified keyword or resolvable symbol k, and a
  spec, spec-name, predicate or regex-op makes an entry in the
  registry mapping k to the spec. Use nil to remove an entry in
  the registry for k.">def</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/fdef" title="clojure.spec.alpha/fdef
([fn-sym &amp; specs])
Macro
  Takes a symbol naming a function, and one or more of the following:

  :args A regex spec for the function arguments as they were a list to be
    passed to apply - in this way, a single spec can handle functions with
    multiple arities
  :ret A spec for the function's return value
  :fn A spec of the relationship between args and ret - the
    value passed is {:args conformed-args :ret conformed-ret} and is
    expected to contain predicates that relate those values

  Qualifies fn-sym with resolve, or using *ns* if no resolution found.
  Registers an fspec in the global registry, where it can be retrieved
  by calling get-spec with the var or fully-qualified symbol.

  Once registered, function specs are included in doc, checked by
  instrument, tested by the runner clojure.spec.test.alpha/check, and (if
  a macro) used to explain errors during macroexpansion.

  Note that :fn specs require the presence of :args and :ret specs to
  conform values, and so :fn specs will be ignored if :args or :ret
  are missing.

[ documentation truncated.  Click link for the rest. ]">fdef</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/registry" title="clojure.spec.alpha/registry
([])
  returns the registry map, prefer 'get-spec' to lookup a spec by name">registry</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/get-spec" title="clojure.spec.alpha/get-spec
([k])
  Returns spec registered for keyword/symbol/var k, or nil.">get-spec</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/spec_q" title="clojure.spec.alpha/spec?
([x])
  returns x if x is a spec object, else logical false">spec?</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/spec" title="clojure.spec.alpha/spec
([form &amp; {:keys [gen]}])
Macro
  Takes a single predicate form, e.g. can be the name of a predicate,
  like even?, or a fn literal like #(&lt; % 42). Note that it is not
  generally necessary to wrap predicates in spec when using the rest
  of the spec macros, only to attach a unique generator

  Can also be passed the result of one of the regex ops -
  cat, alt, *, +, ?, in which case it will return a regex-conforming
  spec, useful when nesting an independent regex.
  ---

  Optionally takes :gen generator-fn, which must be a fn of no args that
  returns a test.check generator.

  Returns a spec.">spec</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/with-gen" title="clojure.spec.alpha/with-gen
([spec gen-fn])
  Takes a spec and a no-arg, generator-returning fn and returns a version of
that spec that uses that generator">with-gen</a></code></td>
              </tr>
              <tr class="even">
                <td>Logical</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/and" title="clojure.spec.alpha/and
([&amp; pred-forms])
Macro
  Takes predicate/spec-forms, e.g.

  (s/and even? #(&lt; % 42))

  Returns a spec that returns the conformed value. Successive
  conformed values propagate through rest of predicates.">and</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/or" title="clojure.spec.alpha/or
([&amp; key-pred-forms])
Macro
  Takes key+pred pairs, e.g.

  (s/or :even even? :small #(&lt; % 42))

  Returns a destructuring spec that returns a map entry containing the
  key of the first matching pred and the corresponding value. Thus the
  'key' and 'val' functions can be used to refer generically to the
  components of the tagged return.">or</a></code></td>
              </tr>
              <tr class="odd">
                <td>Collection</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/coll-of" title="clojure.spec.alpha/coll-of
([pred &amp; opts])
Macro
  Returns a spec for a collection of items satisfying pred. Unlike
  'every', coll-of will exhaustively conform every value.

  Same options as 'every'. conform will produce a collection
  corresponding to :into if supplied, else will match the input collection,
  avoiding rebuilding when possible.

  See also - every, map-of">coll-of</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/map-of" title="clojure.spec.alpha/map-of
([kpred vpred &amp; opts])
Macro
  Returns a spec for a map whose keys satisfy kpred and vals satisfy
  vpred. Unlike 'every-kv', map-of will exhaustively conform every
  value.

  Same options as 'every', :kind defaults to map?, with the addition of:

  :conform-keys - conform keys as well as values (default false)

  See also - every-kv">map-of</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/every" title="clojure.spec.alpha/every
([pred &amp; {:keys [into kind count max-count min-count distinct gen-max gen], :as
opts}])
Macro
  takes a pred and validates collection elements against that pred.

  Note that 'every' does not do exhaustive checking, rather it samples
  *coll-check-limit* elements. Nor (as a result) does it do any
  conforming of elements. 'explain' will report at most *coll-error-limit*
  problems.  Thus 'every' should be suitable for potentially large
  collections.

  Takes several kwargs options that further constrain the collection:

  :kind - a pred that the collection type must satisfy, e.g. vector?
        (default nil) Note that if :kind is specified and :into is
        not, this pred must generate in order for every to generate.
  :count - specifies coll has exactly this count (default nil)
  :min-count, :max-count - coll has count (&lt;= min-count count max-count)
(defaults nil)
  :distinct - all the elements are distinct (default nil)

  And additional args that control gen

  :gen-max - the maximum coll size to generate (default 20)

[ documentation truncated.  Click link for the rest. ]">every</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/every-kv" title="clojure.spec.alpha/every-kv
([kpred vpred &amp; opts])
Macro
  like 'every' but takes separate key and val preds and works on associative
collections.

  Same options as 'every', :into defaults to {}

  See also - map-of">every-kv</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/keys" title="clojure.spec.alpha/keys
([&amp; {:keys [req req-un opt opt-un gen]}])
Macro
  Creates and returns a map validating spec. :req and :opt are both
  vectors of namespaced-qualified keywords. The validator will ensure
  the :req keys are present. The :opt keys serve as documentation and
  may be used by the generator.

  The :req key vector supports 'and' and 'or' for key groups:

  (s/keys :req [::x ::y (or ::secret (and ::user ::pwd))] :opt [::z])

  There are also -un versions of :req and :opt. These allow
  you to connect unqualified keys to specs.  In each case, fully
  qualfied keywords are passed, which name the specs, but unqualified
  keys (with the same name component) are expected and checked at
  conform-time, and generated during gen:

  (s/keys :req-un [:my.ns/x :my.ns/y])

  The above says keys :x and :y are required, and will be validated
  and generated by specs (if they exist) named :my.ns/x :my.ns/y
  respectively.

  In addition, the values of *all* namespace-qualified keys will be validated

[ documentation truncated.  Click link for the rest. ]">keys</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/merge" title="clojure.spec.alpha/merge
([&amp; pred-forms])
Macro
  Takes map-validating specs (e.g. 'keys' specs) and
  returns a spec that returns a conformed map satisfying all of the
  specs.  Unlike 'and', merge can generate maps satisfying the
  union of the predicates.">merge</a></code></td>
              </tr>
              <tr class="even">
                <td>Regex</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/cat" title="clojure.spec.alpha/cat
([&amp; key-pred-forms])
Macro
  Takes key+pred pairs, e.g.

  (s/cat :e even? :o odd?)

  Returns a regex op that matches (all) values in sequence, returning a map
  containing the keys of each pred and the corresponding value.">cat</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/alt" title="clojure.spec.alpha/alt
([&amp; key-pred-forms])
Macro
  Takes key+pred pairs, e.g.

  (s/alt :even even? :small #(&lt; % 42))

  Returns a regex op that returns a map entry containing the key of the
  first matching pred and the corresponding value. Thus the
  'key' and 'val' functions can be used to refer generically to the
  components of the tagged return">alt</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/*" title="clojure.spec.alpha/*
([pred-form])
Macro
  Returns a regex op that matches zero or more values matching
  pred. Produces a vector of matches iff there is at least one match">*</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/%2B" title="clojure.spec.alpha/+
([pred-form])
Macro
  Returns a regex op that matches one or more values matching
  pred. Produces a vector of matches">+</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/_q" title="clojure.spec.alpha/?
([pred-form])
Macro
  Returns a regex op that matches zero or one value matching
  pred. Produces a single value (not a collection) if matched.">?</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/%26" title="clojure.spec.alpha/&amp;
([re &amp; preds])
Macro
  takes a regex op re, and predicates. Returns a regex-op that consumes
  input as per re but subjects the resulting value to the
  conjunction of the predicates, and any conforming they might perform.">&amp;</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/keys*" title="clojure.spec.alpha/keys*
([&amp; kspecs])
Macro
  takes the same arguments as spec/keys and returns a regex op that matches
sequences of key/values,
  converts them into a map, and conforms that map with a corresponding
  spec/keys call:

  user=&gt; (s/conform (s/keys :req-un [::a ::c]) {:a 1 :c 2})
  {:a 1, :c 2}
  user=&gt; (s/conform (s/keys* :req-un [::a ::c]) [:a 1 :c 2])
  {:a 1, :c 2}

  the resulting regex op can be composed into a larger regex:

  user=&gt; (s/conform (s/cat :i1 integer? :m (s/keys* :req-un [::a ::c]) :i2
integer?) [42 :a 1 :c 2 :d 4 99])
  {:i1 42, :m {:a 1, :c 2, :d 4}, :i2 99}">keys*</a></code></td>
              </tr>
              <tr class="odd">
                <td>Range</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/int-in" title="clojure.spec.alpha/int-in
([start end])
Macro
  Returns a spec that validates fixed precision integers in the
  range from start (inclusive) to end (exclusive).">int-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/inst-in" title="clojure.spec.alpha/inst-in
([start end])
Macro
  Returns a spec that validates insts in the range from start
(inclusive) to end (exclusive).">inst-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/double-in" title="clojure.spec.alpha/double-in
([&amp; {:keys [infinite? NaN? min max], :or {infinite? true, NaN? true}, :as m}])
Macro
  Specs a 64-bit floating point number. Options:

    :infinite? - whether +/- infinity allowed (default true)
    :NaN?      - whether NaN allowed (default true)
    :min       - minimum value (inclusive, default none)
    :max       - maximum value (inclusive, default none)">double-in</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/int-in-range_q" title="clojure.spec.alpha/int-in-range?
([start end val])
  Return true if start &lt;= val, val &lt; end and val is a fixed
  precision integer.">int-in-range?</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/inst-in-range_q" title="clojure.spec.alpha/inst-in-range?
([start end inst])
  Return true if inst at or after start and before end">inst-in-range?</a></code></td>
              </tr>
              <tr class="even">
                <td>Other</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/nilable" title="clojure.spec.alpha/nilable
([pred])
Macro
  returns a spec that accepts nil and values satisfying pred">nilable</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/multi-spec" title="clojure.spec.alpha/multi-spec
([mm retag])
Macro
  Takes the name of a spec/predicate-returning multimethod and a
  tag-restoring keyword or fn (retag).  Returns a spec that when
  conforming or explaining data will pass it to the multimethod to get
  an appropriate spec. You can e.g. use multi-spec to dynamically and
  extensibly associate specs with 'tagged' data (i.e. data where one
  of the fields indicates the shape of the rest of the structure).

  (defmulti mspec :tag)

  The methods should ignore their argument and return a predicate/spec:
  (defmethod mspec :int [_] (s/keys :req-un [::tag ::i]))

  retag is used during generation to retag generated values with
  matching tags. retag can either be a keyword, at which key the
  dispatch-tag will be assoc'ed, or a fn of generated value and
  dispatch-tag that should return an appropriately retagged value.

  Note that because the tags themselves comprise an open set,
  the tag key spec cannot enumerate the values, but can e.g.
  test for keyword?.

  Note also that the dispatch values of the multimethod will be

[ documentation truncated.  Click link for the rest. ]">multi-spec</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/fspec" title="clojure.spec.alpha/fspec
([&amp; {:keys [args ret fn gen], :or {ret (quote clojure.core/any?)}}])
Macro
  takes :args :ret and (optional) :fn kwargs whose values are preds
  and returns a spec whose conform/explain take a fn and validates it
  using generative testing. The conformed value is always the fn itself.

  See 'fdef' for a single operation that creates an fspec and
  registers it, as well as a full description of :args, :ret and :fn

  fspecs can generate functions that validate the arguments and
  fabricate a return value compliant with the :ret spec, ignoring
  the :fn spec if present.

  Optionally takes :gen generator-fn, which must be a fn of no args
  that returns a test.check generator.">fspec</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/conformer" title="clojure.spec.alpha/conformer
([f] [f unf])
Macro
  takes a predicate function with the semantics of conform i.e. it should return
either a
  (possibly converted) value or :clojure.spec.alpha/invalid, and returns a
  spec that uses it as a predicate/conformer. Optionally takes a
  second fn that does unform of result of first">conformer</a></code></td>
              </tr>
              <tr class="odd">
                <td>Custom explain</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/explain-printer" title="clojure.spec.alpha/explain-printer
([ed])
  Default printer for explain-data. nil indicates a successful validation.">explain-printer</a> <a href="https://clojuredocs.org/clojure_core/clojure.spec.alpha/*explain-out*" title="clojure.spec.alpha/*explain-out*">*explain-out*</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Predicates with test.check generators</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Numbers</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/number_q" title="clojure.core/number?
([x])
  Returns true if x is a Number">number?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/rational_q" title="clojure.core/rational?
([n])
  Returns true if n is a rational number">rational?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/integer_q" title="clojure.core/integer?
([n])
  Returns true if n is an integer">integer?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ratio_q" title="clojure.core/ratio?
([n])
  Returns true if n is a Ratio">ratio?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/decimal_q" title="clojure.core/decimal?
([n])
  Returns true if n is a BigDecimal">decimal?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/float_q" title="clojure.core/float?
([n])
  Returns true if n is a floating point number">float?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/zero_q" title="clojure.core/zero?
([num])
  Returns true if num is zero, else false">zero?</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/double_q" title="clojure.core/double?
([x])
  Return true if x is a Double">double?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/int_q" title="clojure.core/int?
([x])
  Return true if x is a fixed precision integer">int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nat-int_q" title="clojure.core/nat-int?
([x])
  Return true if x is a non-negative fixed precision integer">nat-int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/neg-int_q" title="clojure.core/neg-int?
([x])
  Return true if x is a negative fixed precision integer">neg-int?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pos-int_q" title="clojure.core/pos-int?
([x])
  Return true if x is a positive fixed precision integer">pos-int?</a></code></td>
              </tr>
              <tr class="even">
                <td>Symbols, keywords</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/keyword_q" title="clojure.core/keyword?
([x])
  Return true if x is a Keyword">keyword?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/symbol_q" title="clojure.core/symbol?
([x])
  Return true if x is a Symbol">symbol?</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/ident_q" title="clojure.core/ident?
([x])
  Return true if x is a symbol or keyword">ident?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/qualified-ident_q" title="clojure.core/qualified-ident?
([x])
  Return true if x is a symbol or keyword with a namespace">qualified-ident?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/qualified-keyword_q" title="clojure.core/qualified-keyword?
([x])
  Return true if x is a keyword with a namespace">qualified-keyword?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/qualified-symbol_q" title="clojure.core/qualified-symbol?
([x])
  Return true if x is a symbol with a namespace">qualified-symbol?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/simple-ident_q" title="clojure.core/simple-ident?
([x])
  Return true if x is a symbol or keyword without a namespace">simple-ident?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/simple-keyword_q" title="clojure.core/simple-keyword?
([x])
  Return true if x is a keyword without a namespace">simple-keyword?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/simple-symbol_q" title="clojure.core/simple-symbol?
([x])
  Return true if x is a symbol without a namespace">simple-symbol?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Other scalars</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/string_q" title="clojure.core/string?
([x])
  Return true if x is a String">string?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/true_q" title="clojure.core/true?
([x])
  Returns true if x is the value true, false otherwise.">true?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/false_q" title="clojure.core/false?
([x])
  Returns true if x is the value false, false otherwise.">false?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/nil_q" title="clojure.core/nil?
([x])
  Returns true if x is nil, false otherwise.">nil?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some_q" title="clojure.core/some?
([x])
  Returns true if x is not nil, false otherwise.">some?</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/boolean_q" title="clojure.core/boolean?
([x])
  Return true if x is a Boolean">boolean?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bytes_q" title="clojure.core/bytes?
([x])
  Return true if x is a byte array">bytes?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/inst_q" title="clojure.core/inst?
([x])
  Return true if x satisfies Inst">inst?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/uri_q" title="clojure.core/uri?
([x])
  Return true if x is a java.net.URI">uri?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/uuid_q" title="clojure.core/uuid?
([x])
  Return true if x is a java.util.UUID">uuid?</a></code></td>
              </tr>
              <tr class="even">
                <td>Collections</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/list_q" title="clojure.core/list?
([x])
  Returns true if x implements IPersistentList">list?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/map_q" title="clojure.core/map?
([x])
  Return true if x implements IPersistentMap">map?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set_q" title="clojure.core/set?
([x])
  Returns true if x implements IPersistentSet">set?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vector_q" title="clojure.core/vector?
([x])
  Return true if x implements IPersistentVector">vector?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/associative_q" title="clojure.core/associative?
([coll])
  Returns true if coll implements Associative">associative?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/coll_q" title="clojure.core/coll?
([x])
  Returns true if x implements IPersistentCollection">coll?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/sequential_q" title="clojure.core/sequential?
([coll])
  Returns true if coll implements Sequential">sequential?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/seq_q" title="clojure.core/seq?
([x])
  Return true if x implements ISeq">seq?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/empty_q" title="clojure.core/empty?
([coll])
  Returns true if coll has no items - same as (not (seq coll)).
  Please use the idiom (seq x) rather than (not (empty? x))">empty?</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/indexed_q" title="clojure.core/indexed?
([coll])
  Return true if coll implements Indexed, indicating efficient lookup by index">indexed?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/seqable_q" title="clojure.core/seqable?
([x])
  Return true if the seq function is supported for x">seqable?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Other</td>
                <td><code>(1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/any_q" title="clojure.core/any?
([x])
  Returns true given any argument.">any?</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>IO</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>to/from ...</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/spit" title="clojure.core/spit
([f content &amp; options])
  Opposite of slurp.  Opens f with writer, writes content, then
  closes f. Options passed to clojure.java.io/writer.">spit</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/slurp" title="clojure.core/slurp
([f &amp; opts])
  Opens a reader on f and reads all its contents, returning a string.
  See clojure.java.io/reader for a complete list of supported arguments.">slurp</a> (to writer/from reader, Socket, string with file name, URI, etc.)</code></td>
              </tr>
              <tr class="even">
                <td>to *out*</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/pr" title="clojure.core/pr
([] [x] [x &amp; more])
  Prints the object(s) to the output stream that is the current value
  of *out*.  Prints the object(s), separated by spaces if there is
  more than one.  By default, pr and prn print in a way that objects
  can be read by the reader">pr</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/prn" title="clojure.core/prn
([&amp; more])
  Same as pr followed by (newline). Observes *flush-on-newline*">prn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/print" title="clojure.core/print
([&amp; more])
  Prints the object(s) to the output stream that is the current value
  of *out*.  print and println produce output for human consumption.">print</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/printf" title="clojure.core/printf
([fmt &amp; args])
  Prints formatted output, as per format">printf</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/println" title="clojure.core/println
([&amp; more])
  Same as print followed by (newline)">println</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/newline" title="clojure.core/newline
([])
  Writes a platform-specific newline to *out*">newline</a> (clojure.pprint/) <a href="https://clojuredocs.org/clojure_core/clojure.pprint/print-table" title="clojure.pprint/print-table
([ks rows] [rows])
  Prints a collection of maps in a textual table. Prints table headings
   ks, and then a line of output for each row, corresponding to the keys
   in ks. If ks are not specified, use the keys of the first item in rows.">print-table</a></code></td>
              </tr>
              <tr class="odd">
                <td>to writer</td>
                <td><code>(clojure.pprint/) <a href="https://clojuredocs.org/clojure_core/clojure.pprint/pprint" title="clojure.pprint/pprint
([object] [object writer])
  Pretty print object to the optional output writer. If the writer is not
provided,
print the object to the currently bound value of *out*.">pprint</a> <a href="https://clojuredocs.org/clojure_core/clojure.pprint/cl-format" title="clojure.pprint/cl-format
([writer format-in &amp; args])
  An implementation of a Common Lisp compatible format function. cl-format
formats its
arguments to an output stream or string based on the format control string
given. It
supports sophisticated formatting of structured data.

Writer is an instance of java.io.Writer, true to output to *out* or nil to
output
to a string, format-in is the format control string and the remaining arguments
are the data to be formatted.

The format control string is a string to be output with embedded 'format
directives'
describing how to format the various arguments passed in.

If writer is nil, cl-format returns the formatted result string. Otherwise,
cl-format
returns nil.

For example:
 (let [results [46 38 22]]
        (cl-format true &quot;There ~[are~;is~:;are~]~:* ~d result~:p: ~{~d~^, ~}~%&quot;
                   (count results) results))

[ documentation truncated.  Click link for the rest. ]">cl-format</a> also: (binding [*out* writer] ...)</code></td>
              </tr>
              <tr class="even">
                <td>to string</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/format" title="clojure.core/format
([fmt &amp; args])
  Formats a string using java.lang.String.format, see java.util.Formatter for
format
  string syntax">format</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-out-str" title="clojure.core/with-out-str
([&amp; body])
Macro
  Evaluates exprs in a context in which *out* is bound to a fresh
  StringWriter.  Returns the string created by any nested printing
  calls.">with-out-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pr-str" title="clojure.core/pr-str
([&amp; xs])
  pr to a string, returning it">pr-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/prn-str" title="clojure.core/prn-str
([&amp; xs])
  prn to a string, returning it">prn-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/print-str" title="clojure.core/print-str
([&amp; xs])
  print to a string, returning it">print-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/println-str" title="clojure.core/println-str
([&amp; xs])
  println to a string, returning it">println-str</a></code></td>
              </tr>
              <tr class="odd">
                <td>from *in*</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/read-line" title="clojure.core/read-line
([])
  Reads the next line from stream that is the current value of *in* .">read-line</a> (clojure.edn/) <a href="https://clojuredocs.org/clojure_core/clojure.edn/read" title="clojure.edn/read
([] [stream] [opts stream])
  Reads the next object from stream, which must be an instance of
  java.io.PushbackReader or some derivee.  stream defaults to the
  current value of *in*.

  Reads data in the edn format (subset of Clojure data):
  https://github.com/edn-format/edn

  opts is a map that can include the following keys:
  :eof - value to return on end-of-file. When not supplied, eof throws an
exception.
  :readers  - a map of tag symbols to data-reader functions to be considered
before default-data-readers.
              When not supplied, only the default-data-readers will be used.
  :default - A function of two args, that will, if present and no reader is
found for a tag,
             be called with the tag and the value.">read</a> (clojure.tools.reader.edn/) <a href="https://github.com/clojure/tools.reader" title="clojure.tools.reader.edn/read
([] [reader] [{:keys [eof], :as opts} reader] [reader eof-error? eof opts])
  Reads the first object from an IPushbackReader or a java.io.PushbackReader.
   Returns the object read. If EOF, throws if eof-error? is true otherwise
returns eof.
   If no reader is provided, *in* will be used.

   Reads data in the edn format (subset of Clojure data):
   https://github.com/edn-format/edn

   clojure.tools.reader.edn/read doesn't depend on dynamic Vars, all
configuration
   is done by passing an opt map.

   opts is a map that can include the following keys:
   :eof - value to return on end-of-file. When not supplied, eof throws an
exception.
   :readers  - a map of tag symbols to data-reader functions to be considered
before default-data-readers.
              When not supplied, only the default-data-readers will be used.
   :default - A function of two args, that will, if present and no reader is
found for a tag,
              be called with the tag and the value.">read</a></code></td>
              </tr>
              <tr class="even">
                <td>from reader</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/line-seq" title="clojure.core/line-seq
([rdr])
  Returns the lines of text from rdr as a lazy sequence of strings.
  rdr must implement java.io.BufferedReader.">line-seq</a> (clojure.edn/) <a href="https://clojuredocs.org/clojure_core/clojure.edn/read" title="clojure.edn/read
([] [stream] [opts stream])
  Reads the next object from stream, which must be an instance of
  java.io.PushbackReader or some derivee.  stream defaults to the
  current value of *in*.

  Reads data in the edn format (subset of Clojure data):
  https://github.com/edn-format/edn

  opts is a map that can include the following keys:
  :eof - value to return on end-of-file. When not supplied, eof throws an
exception.
  :readers  - a map of tag symbols to data-reader functions to be considered
before default-data-readers.
              When not supplied, only the default-data-readers will be used.
  :default - A function of two args, that will, if present and no reader is
found for a tag,
             be called with the tag and the value.">read</a> (clojure.tools.reader.edn/) <a href="https://github.com/clojure/tools.reader" title="clojure.tools.reader.edn/read
([] [reader] [{:keys [eof], :as opts} reader] [reader eof-error? eof opts])
  Reads the first object from an IPushbackReader or a java.io.PushbackReader.
   Returns the object read. If EOF, throws if eof-error? is true otherwise
returns eof.
   If no reader is provided, *in* will be used.

   Reads data in the edn format (subset of Clojure data):
   https://github.com/edn-format/edn

   clojure.tools.reader.edn/read doesn't depend on dynamic Vars, all
configuration
   is done by passing an opt map.

   opts is a map that can include the following keys:
   :eof - value to return on end-of-file. When not supplied, eof throws an
exception.
   :readers  - a map of tag symbols to data-reader functions to be considered
before default-data-readers.
              When not supplied, only the default-data-readers will be used.
   :default - A function of two args, that will, if present and no reader is
found for a tag,
              be called with the tag and the value.">read</a> also: (binding [*in* reader] ...) <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Reader.html">java.io.Reader</a></code></td>
              </tr>
              <tr class="odd">
                <td>from string</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/with-in-str" title="clojure.core/with-in-str
([s &amp; body])
Macro
  Evaluates body in a context in which *in* is bound to a fresh
  StringReader initialized with the string s.">with-in-str</a> (clojure.edn/) <a href="https://clojuredocs.org/clojure_core/clojure.edn/read-string" title="clojure.edn/read-string
([s] [opts s])
  Reads one object from the string s. Returns nil when s is nil or empty.

  Reads data in the edn format (subset of Clojure data):
  https://github.com/edn-format/edn

  opts is a map as per clojure.edn/read">read-string</a> (clojure.tools.reader.edn/) <a href="https://github.com/clojure/tools.reader" title="clojure.tools.reader.edn/read-string
([s] [opts s])
  Reads one object from the string s.
   Returns nil when s is nil or empty.

   Reads data in the edn format (subset of Clojure data):
   https://github.com/edn-format/edn

   opts is a map as per clojure.tools.reader.edn/read">read-string</a></code></td>
              </tr>
              <tr class="even">
                <td>Open</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/with-open" title="clojure.core/with-open
([bindings &amp; body])
Macro
  bindings =&gt; [name init ...]

  Evaluates body in a try expression with names bound to the values
  of the inits, and a finally clause that calls (.close name) on each
  name in reverse order.">with-open</a> (clojure.java.io/) text: <a href="https://clojuredocs.org/clojure_core/clojure.java.io/reader" title="clojure.java.io/reader
([x &amp; opts])
  Attempts to coerce its argument into an open java.io.Reader.
   Default implementations always return a java.io.BufferedReader.

   Default implementations are provided for Reader, BufferedReader,
   InputStream, File, URI, URL, Socket, byte arrays, character arrays,
   and String.

   If argument is a String, it tries to resolve it first as a URI, then
   as a local file name.  URIs with a 'file' protocol are converted to
   local file names.

   Should be used inside with-open to ensure the Reader is properly
   closed.">reader</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/writer" title="clojure.java.io/writer
([x &amp; opts])
  Attempts to coerce its argument into an open java.io.Writer.
   Default implementations always return a java.io.BufferedWriter.

   Default implementations are provided for Writer, BufferedWriter,
   OutputStream, File, URI, URL, Socket, and String.

   If the argument is a String, it tries to resolve it first as a URI, then
   as a local file name.  URIs with a 'file' protocol are converted to
   local file names.

   Should be used inside with-open to ensure the Writer is properly
   closed.">writer</a> binary: <a href="https://clojuredocs.org/clojure_core/clojure.java.io/input-stream" title="clojure.java.io/input-stream
([x &amp; opts])
  Attempts to coerce its argument into an open java.io.InputStream.
   Default implementations always return a java.io.BufferedInputStream.

   Default implementations are defined for InputStream, File, URI, URL,
   Socket, byte array, and String arguments.

   If the argument is a String, it tries to resolve it first as a URI, then
   as a local file name.  URIs with a 'file' protocol are converted to
   local file names.

   Should be used inside with-open to ensure the InputStream is properly
   closed.">input-stream</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/output-stream" title="clojure.java.io/output-stream
([x &amp; opts])
  Attempts to coerce its argument into an open java.io.OutputStream.
   Default implementations always return a java.io.BufferedOutputStream.

   Default implementations are defined for OutputStream, File, URI, URL,
   Socket, and String arguments.

   If the argument is a String, it tries to resolve it first as a URI, then
   as a local file name.  URIs with a 'file' protocol are converted to
   local file names.

   Should be used inside with-open to ensure the OutputStream is
   properly closed.">output-stream</a></code></td>
              </tr>
              <tr class="odd">
                <td>Binary</td>
                <td><code>(.write ostream byte-arr) (.read istream byte-arr) <a href="https://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html">java.io.OutputStream</a> <a href="https://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html">java.io.InputStream</a> GitHub: <a href="https://github.com/ztellman/gloss">gloss</a> <a href="https://github.com/rosejn/byte-spec">byte-spec</a></code></td>
              </tr>
              <tr class="even">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/flush" title="clojure.core/flush
([])
  Flushes the output stream that is the current value of
  *out*">flush</a> (.close s) <a href="https://clojuredocs.org/clojure_core/clojure.core/file-seq" title="clojure.core/file-seq
([dir])
  A tree seq on java.io.Files">file-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*in*" title="clojure.core/*in*
  A java.io.Reader object representing standard input for read operations.

  Defaults to System/in, wrapped in a LineNumberingPushbackReader">*in*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*out*" title="clojure.core/*out*
  A java.io.Writer object representing standard output for print operations.

  Defaults to System/out, wrapped in an OutputStreamWriter">*out*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*err*" title="clojure.core/*err*
  A java.io.Writer object representing standard error for print operations.

  Defaults to System/err, wrapped in a PrintWriter">*err*</a> (clojure.java.io/) <a href="https://clojuredocs.org/clojure_core/clojure.java.io/file" title="clojure.java.io/file
([arg] [parent child] [parent child &amp; more])
  Returns a java.io.File, passing each arg to as-file.  Multiple-arg
   versions treat the first argument as parent and subsequent args as
   children relative to the parent.">file</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/copy" title="clojure.java.io/copy
([input output &amp; opts])
  Copies input to output.  Returns nil or throws IOException.
  Input may be an InputStream, Reader, File, byte[], char[], or String.
  Output may be an OutputStream, Writer, or File.

  Options are key/value pairs and may be one of

    :buffer-size  buffer size to use, default is 1024.
    :encoding     encoding to use if converting between
                  byte and char streams.

  Does not close any streams except those it opens itself
  (on a File).">copy</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/delete-file" title="clojure.java.io/delete-file
([f &amp; [silently]])
  Delete file f. If silently is nil or false, raise an exception on failure,
else return the value of silently.">delete-file</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/resource" title="clojure.java.io/resource
([n] [n loader])
  Returns the URL for a named resource. Use the context class loader
   if no loader is specified.">resource</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/as-file" title="clojure.java.io/as-file
([x])
  Coerce argument to a file.">as-file</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/as-url" title="clojure.java.io/as-url
([x])
  Coerce argument to a URL.">as-url</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.io/as-relative-path" title="clojure.java.io/as-relative-path
([x])
  Take an as-file-able thing and return a string if it is
   a relative path, else IllegalArgumentException.">as-relative-path</a> GitHub: <a href="https://github.com/funcool/fs">fs</a></code></td>
              </tr>
              <tr class="odd">
                <td>Data readers</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*data-readers*" title="clojure.core/*data-readers*
  Map from reader tag symbols to data reader Vars.

  When Clojure starts, it searches for files named 'data_readers.clj'
  and 'data_readers.cljc' at the root of the classpath. Each such file
  must contain a literal map of symbols, like this:

      {foo/bar my.project.foo/bar
       foo/baz my.project/baz}

  The first symbol in each pair is a tag that will be recognized by
  the Clojure reader. The second symbol in the pair is the
  fully-qualified name of a Var which will be invoked by the reader to
  parse the form following the tag. For example, given the
  data_readers.clj file above, the Clojure reader would parse this
  form:

      #foo/bar [1 2 3]

  by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The
  data reader function is invoked on the form AFTER it has been read
  as a normal Clojure data structure by the reader.

  Reader tags without namespace qualifiers are reserved for
  Clojure. Default reader tags are defined in

[ documentation truncated.  Click link for the rest. ]">*data-readers*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/default-data-readers" title="clojure.core/default-data-readers
  Default map of data reader functions provided by Clojure. May be
  overridden by binding *data-readers*.">default-data-readers</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*default-data-reader-fn*" title="clojure.core/*default-data-reader-fn*
  When no data reader is found for a tag and *default-data-reader-fn*
  is non-nil, it will be called with two arguments,
  the tag and the value.  If *default-data-reader-fn* is nil (the
  default), an exception will be thrown for the unknown tag.">*default-data-reader-fn*</a></code></td>
              </tr>
              <tr class="even">
                <td>tap</td>
                <td><code>(1.10) <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/tap>" title="clojure.core/tap&gt;
([x])
  sends x to any taps. Will not block. Returns true if there was room in the
queue,
  false if not (dropped).">tap&gt;</a> <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/add-tap" title="clojure.core/add-tap
([f])
  adds f, a fn of one argument, to the tap set. This function will be called
with anything sent via tap&gt;.
  This function may (briefly) block (e.g. for streams), and will never impede
calls to tap&gt;,
  but blocking indefinitely may cause tap values to be dropped.
  Remember f in order to remove-tap">add-tap</a> <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/remove-tap" title="clojure.core/remove-tap
([f])
  Remove f from the tap set.">remove-tap</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
      </div><!-- /column -->
    </div><!-- /page -->
    <div class="page">
      <div class="column">
        <div class="section">
          <h2>Functions</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/fn" title="clojure.core/fn
  (fn name? [params*] exprs*)
  (fn name? ([params*] exprs*) +)
([&amp; sigs])
Special Form
  params =&gt; positional-params*, or positional-params* &amp; rest-param
  positional-param =&gt; binding-form
  rest-param =&gt; binding-form
  binding-form =&gt; name, or destructuring-form

  Defines a function.

  See https://clojure.org/reference/special_forms#fn for more information

  Please see http://clojure.org/special_forms#fn
Spec
  args: (cat :fn-name (? simple-symbol?) :fn-tail (alt :arity-1
:clojure.core.specs.alpha/params+body :arity-n (+ (spec
:clojure.core.specs.alpha/params+body))))
  ret: any?">fn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defn" title="clojure.core/defn
([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string?
attr-map? ([params*] prepost-map? body) + attr-map?])
Macro
  Same as (def name (fn [params* ] exprs*)) or (def
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    to the var metadata. prepost-map defines a map with optional keys
    :pre and :post that contain collections of pre or post conditions.
Spec
  args: (cat :fn-name simple-symbol? :docstring (? string?) :meta (? map?)
:fn-tail (alt :arity-1 :clojure.core.specs.alpha/params+body :arity-n (cat
:bodies (+ (spec :clojure.core.specs.alpha/params+body)) :attr-map (? map?))))
  ret: any?">defn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defn-" title="clojure.core/defn-
([name &amp; decls])
Macro
  same as defn, yielding non-public def
Spec
  args: (cat :fn-name simple-symbol? :docstring (? string?) :meta (? map?)
:fn-tail (alt :arity-1 :clojure.core.specs.alpha/params+body :arity-n (cat
:bodies (+ (spec :clojure.core.specs.alpha/params+body)) :attr-map (? map?))))
  ret: any?">defn-</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/definline" title="clojure.core/definline
([name &amp; decl])
Macro
  Experimental - like defmacro, except defines a named function whose
  body is the expansion, calls to which may be expanded inline as if
  it were a macro. Cannot be used with variadic (&amp;) args.">definline</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/identity" title="clojure.core/identity
([x])
  Returns its argument.">identity</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/constantly" title="clojure.core/constantly
([x])
  Returns a function that takes any number of arguments and returns x.">constantly</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/memfn" title="clojure.core/memfn
([name &amp; args])
Macro
  Expands into code that creates a fn that expects to be passed an
  object and any args and calls the named instance method on the
  object passing the args. Use when you want to treat a Java method as
  a first-class fn. name may be type-hinted with the method receiver's
  type in order to avoid reflective calls.">memfn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/comp" title="clojure.core/comp
([] [f] [f g] [f g &amp; fs])
  Takes a set of functions and returns a fn that is the composition
  of those fns.  The returned fn takes a variable number of args,
  applies the rightmost of fns to the args, the next
  fn (right-to-left) to the result, etc.">comp</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/complement" title="clojure.core/complement
([f])
  Takes a fn f and returns a fn that takes the same arguments as f,
  has the same effects, if any, and returns the opposite truth value.">complement</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/partial" title="clojure.core/partial
([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 &amp; more])
  Takes a function f and fewer than the normal arguments to f, and
  returns a fn that takes a variable number of additional args. When
  called, the returned function calls f with args + additional args.">partial</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/juxt" title="clojure.core/juxt
([f] [f g] [f g h] [f g h &amp; fs])
  Takes a set of functions and returns a fn that is the juxtaposition
  of those fns.  The returned fn takes a variable number of args, and
  returns a vector containing the result of applying each fn to the
  args (left-to-right).
  ((juxt a b c) x) =&gt; [(a x) (b x) (c x)]">juxt</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/memoize" title="clojure.core/memoize
([f])
  Returns a memoized version of a referentially transparent function. The
  memoized version of the function keeps a cache of the mapping from arguments
  to results and, when calls with the same arguments are repeated often, has
  higher performance at the expense of higher memory use.">memoize</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/fnil" title="clojure.core/fnil
([f x] [f x y] [f x y z])
  Takes a function f, and returns a function that calls f, replacing
  a nil first argument to f with the supplied value x. Higher arity
  versions can replace arguments in the second and third
  positions (y, z). Note that the function f can take any number of
  arguments, not just the one(s) being nil-patched.">fnil</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/every-pred" title="clojure.core/every-pred
([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 &amp; ps])
  Takes a set of predicates and returns a function f that returns true if all of
its
  composing predicates return a logical true value against all of its arguments,
else it returns
  false. Note that f is short-circuiting in that it will stop execution on the
first
  argument that triggers a logical false result against the original predicates.">every-pred</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some-fn" title="clojure.core/some-fn
([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 &amp; ps])
  Takes a set of predicates and returns a function f that returns the first
logical true value
  returned by one of its composing predicates against any of its arguments, else
it returns
  logical false. Note that f is short-circuiting in that it will stop execution
on the first
  argument that triggers a logical true result against the original predicates.">some-fn</a></code></td>
              </tr>
              <tr class="even">
                <td>Call</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/apply" title="clojure.core/apply
([f args] [f x args] [f x y args] [f x y z args] [f a b c d &amp; args])
  Applies fn f to the argument list formed by prepending intervening arguments
to args.">apply</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E" title="clojure.core/-&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  second item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  second item in second form, etc.">-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E%3E" title="clojure.core/-&gt;&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  last item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  last item in second form, etc.">-&gt;&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/trampoline" title="clojure.core/trampoline
([f] [f &amp; args])
  trampoline can be used to convert algorithms requiring mutual
  recursion without stack consumption. Calls f with supplied args, if
  any. If f returns a fn, calls that fn with no arguments, and
  continues to repeat, until the return value is not a fn, then
  returns that non-fn value. Note that if you want to return a fn as a
  final value, you must wrap it in some data structure and unpack it
  after trampoline returns.">trampoline</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/as-%3E" title="clojure.core/as-&gt;
([expr name &amp; forms])
Macro
  Binds name to expr, evaluates the first form in the lexical context
  of that binding, then binds name to that result, repeating for each
  successive form, returning the result of the last form.">as-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cond-%3E" title="clojure.core/cond-&gt;
([expr &amp; clauses])
Macro
  Takes an expression and a set of test/form pairs. Threads expr (via -&gt;)
  through each form for which the corresponding test
  expression is true. Note that, unlike cond branching, cond-&gt; threading does
  not short circuit after the first true test expression.">cond-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cond-%3E%3E" title="clojure.core/cond-&gt;&gt;
([expr &amp; clauses])
Macro
  Takes an expression and a set of test/form pairs. Threads expr (via -&gt;&gt;)
  through each form for which the corresponding test expression
  is true.  Note that, unlike cond branching, cond-&gt;&gt; threading does not short
circuit
  after the first true test expression.">cond-&gt;&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some-%3E" title="clojure.core/some-&gt;
([expr &amp; forms])
Macro
  When expr is not nil, threads it into the first form (via -&gt;),
  and when that result is not nil, through the next etc">some-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some-%3E%3E" title="clojure.core/some-&gt;&gt;
([expr &amp; forms])
Macro
  When expr is not nil, threads it into the first form (via -&gt;&gt;),
  and when that result is not nil, through the next etc">some-&gt;&gt;</a></code></td>
              </tr>
              <tr class="odd">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/fn_q" title="clojure.core/fn?
([x])
  Returns true if x implements Fn, i.e. is an object created via fn.">fn?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ifn_q" title="clojure.core/ifn?
([x])
  Returns true if x implements IFn. Note that many data structures
  (e.g. sets and maps) implement IFn">ifn?</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Abstractions (<a href="https://github.com/cemerick/clojure-type-selection-flowchart">Clojure type selection flowchart</a>)</h2>
          <h3>Protocols (<a href="https://clojure.org/reference/protocols">clojure.org/reference/protocols</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Define</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/defprotocol" title="clojure.core/defprotocol
([name &amp; opts+sigs])
Macro
  A protocol is a named set of named methods and their signatures:
  (defprotocol AProtocolName

    ;optional doc string
    &quot;A doc string for AProtocol abstraction&quot;

   ;options
   :extend-via-metadata true

  ;method signatures
    (bar [this a b] &quot;bar docs&quot;)
    (baz [this a] [this a b] [this a b c] &quot;baz docs&quot;))

  No implementations are provided. Docs can be specified for the
  protocol overall and for each method. The above yields a set of
  polymorphic functions and a protocol object. All are
  namespace-qualified by the ns enclosing the definition The resulting
  functions dispatch on the type of their first argument, which is
  required and corresponds to the implicit target object ('this' in
  Java parlance). defprotocol is dynamic, has no special compile-time
  effect, and defines no new types or classes. Implementations of
  the protocol methods can be provided using extend.

[ documentation truncated.  Click link for the rest. ]">defprotocol</a> <code>Slicey (slice [at]))</code></code></td>
              </tr>
              <tr class="even">
                <td>Extend</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/extend-type" title="clojure.core/extend-type
([t &amp; specs])
Macro
  A macro that expands into an extend call. Useful when you are
  supplying the definitions explicitly inline, extend-type
  automatically creates the maps required by extend.  Propagates the
  class as a type hint on the first argument of all fns.

  (extend-type MyType
    Countable
      (cnt [c] ...)
    Foo
      (bar [x y] ...)
      (baz ([x] ...) ([x y &amp; zs] ...)))

  expands into:

  (extend MyType
   Countable
     {:cnt (fn [c] ...)}
   Foo
     {:baz (fn ([x] ...) ([x y &amp; zs] ...))
      :bar (fn [x y] ...)})">extend-type</a> <code>String Slicey (slice [at] ...))</code></code></td>
              </tr>
              <tr class="odd">
                <td>Extend null</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/extend-type" title="clojure.core/extend-type
([t &amp; specs])
Macro
  A macro that expands into an extend call. Useful when you are
  supplying the definitions explicitly inline, extend-type
  automatically creates the maps required by extend.  Propagates the
  class as a type hint on the first argument of all fns.

  (extend-type MyType
    Countable
      (cnt [c] ...)
    Foo
      (bar [x y] ...)
      (baz ([x] ...) ([x y &amp; zs] ...)))

  expands into:

  (extend MyType
   Countable
     {:cnt (fn [c] ...)}
   Foo
     {:baz (fn ([x] ...) ([x y &amp; zs] ...))
      :bar (fn [x y] ...)})">extend-type</a> <code>nil Slicey (slice [_] nil))</code></code></td>
              </tr>
              <tr class="even">
                <td>Reify</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/reify" title="clojure.core/reify
([&amp; opts+specs])
Macro
  reify creates an object implementing a protocol or interface.
  reify is a macro with the following structure:

 (reify options* specs*)

  Currently there are no options.

  Each spec consists of the protocol or interface name followed by zero
  or more method bodies:

  protocol-or-interface-or-Object
  (methodName [args+] body)*

  Methods should be supplied for all methods of the desired
  protocol(s) and interface(s). You can also define overrides for
  methods of Object. Note that the first parameter must be supplied to
  correspond to the target object ('this' in Java parlance). Thus
  methods for interfaces will take one more argument than do the
  interface declarations.  Note also that recur calls to the method
  head should *not* pass the target object, it will be supplied
  automatically and can not be substituted.

[ documentation truncated.  Click link for the rest. ]">reify</a> <code>Slicey (slice [at] ...))</code></code></td>
              </tr>
              <tr class="odd">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/satisfies_q" title="clojure.core/satisfies?
([protocol x])
  Returns true if x satisfies the protocol">satisfies?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/extends_q" title="clojure.core/extends?
([protocol atype])
  Returns true if atype extends protocol">extends?</a></code></td>
              </tr>
              <tr class="even">
                <td>Other</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/extend" title="clojure.core/extend
([atype &amp; proto+mmaps])
  Implementations of protocol methods can be provided using the extend
construct:

  (extend AType
    AProtocol
     {:foo an-existing-fn
      :bar (fn [a b] ...)
      :baz (fn ([a]...) ([a b] ...)...)}
    BProtocol
      {...}
    ...)

  extend takes a type/class (or interface, see below), and one or more
  protocol + method map pairs. It will extend the polymorphism of the
  protocol's methods to call the supplied methods when an AType is
  provided as the first argument.

  Method maps are maps of the keyword-ized method names to ordinary
  fns. This facilitates easy reuse of existing fns and fn maps, for
  code reuse/mixins without derivation or composition. You can extend
  an interface to a protocol. This is primarily to facilitate interop
  with the host (e.g. Java) but opens the door to incidental multiple
  inheritance of implementation since a class can inherit from more

[ documentation truncated.  Click link for the rest. ]">extend</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/extend-protocol" title="clojure.core/extend-protocol
([p &amp; specs])
Macro
  Useful when you want to provide several implementations of the same
  protocol all at once. Takes a single protocol and the implementation
  of that protocol for one or more types. Expands into calls to
  extend-type:

  (extend-protocol Protocol
    AType
      (foo [x] ...)
      (bar [x y] ...)
    BType
      (foo [x] ...)
      (bar [x y] ...)
    AClass
      (foo [x] ...)
      (bar [x y] ...)
    nil
      (foo [x] ...)
      (bar [x y] ...))

  expands into:

  (do

[ documentation truncated.  Click link for the rest. ]">extend-protocol</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/extenders" title="clojure.core/extenders
([protocol])
  Returns a collection of the types explicitly extending protocol">extenders</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Records (<a href="https://clojure.org/reference/datatypes">clojure.org/reference/datatypes</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Define</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/defrecord" title="clojure.core/defrecord
([name [&amp; fields] &amp; opts+specs])
Macro
  (defrecord name [fields*]  options* specs*)

  Options are expressed as sequential keywords and arguments (in any order).

  Supported options:
  :load-ns - if true, importing the record class will cause the
             namespace in which the record was defined to be loaded.
             Defaults to false.

  Each spec consists of a protocol or interface name followed by zero
  or more method bodies:

  protocol-or-interface-or-Object
  (methodName [args*] body)*

  Dynamically generates compiled bytecode for class with the given
  name, in a package with the same name as the current namespace, the
  given fields, and, optionally, methods for protocols and/or
  interfaces.

  The class will have the (immutable) fields named by
  fields, which can have type hints. Protocols/interfaces and methods

[ documentation truncated.  Click link for the rest. ]">defrecord</a> <code>Pair [h t])</code></code></td>
              </tr>
              <tr class="even">
                <td>Access</td>
                <td><code><code>(:h (Pair. 1 2))</code> &rarr; <code>1</code></code></td>
              </tr>
              <tr class="odd">
                <td>Create</td>
                <td><code>Pair. -&gt;Pair map-&gt;Pair</code></td>
              </tr>
              <tr class="even">
                <td>Test</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/record_q" title="clojure.core/record?
([x])
  Returns true if x is a record">record?</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Types (<a href="https://clojure.org/reference/datatypes">clojure.org/reference/datatypes</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Define</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/deftype" title="clojure.core/deftype
([name [&amp; fields] &amp; opts+specs])
Macro
  (deftype name [fields*]  options* specs*)

  Options are expressed as sequential keywords and arguments (in any order).

  Supported options:
  :load-ns - if true, importing the type class will cause the
             namespace in which the type was defined to be loaded.
             Defaults to false.

  Each spec consists of a protocol or interface name followed by zero
  or more method bodies:

  protocol-or-interface-or-Object
  (methodName [args*] body)*

  Dynamically generates compiled bytecode for class with the given
  name, in a package with the same name as the current namespace, the
  given fields, and, optionally, methods for protocols and/or
  interfaces.

  The class will have the (by default, immutable) fields named by
  fields, which can have type hints. Protocols/interfaces and methods

[ documentation truncated.  Click link for the rest. ]">deftype</a> <code>Pair [h t])</code></code></td>
              </tr>
              <tr class="even">
                <td>Access</td>
                <td><code><code>(.h (Pair. 1 2))</code> &rarr; <code>1</code></code></td>
              </tr>
              <tr class="odd">
                <td>Create</td>
                <td><code>Pair. -&gt;Pair</code></td>
              </tr>
              <tr class="even">
                <td>With methods</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/deftype" title="clojure.core/deftype
([name [&amp; fields] &amp; opts+specs])
Macro
  (deftype name [fields*]  options* specs*)

  Options are expressed as sequential keywords and arguments (in any order).

  Supported options:
  :load-ns - if true, importing the type class will cause the
             namespace in which the type was defined to be loaded.
             Defaults to false.

  Each spec consists of a protocol or interface name followed by zero
  or more method bodies:

  protocol-or-interface-or-Object
  (methodName [args*] body)*

  Dynamically generates compiled bytecode for class with the given
  name, in a package with the same name as the current namespace, the
  given fields, and, optionally, methods for protocols and/or
  interfaces.

  The class will have the (by default, immutable) fields named by
  fields, which can have type hints. Protocols/interfaces and methods

[ documentation truncated.  Click link for the rest. ]">deftype</a> <code>Pair [h t]<br>&nbsp;&nbsp;Object<br>&nbsp;&nbsp;(toString [this] (str "&lt;" h "," t "&gt;")))</code></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Multimethods (<a href="https://clojure.org/reference/multimethods">clojure.org/reference/multimethods</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Define</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmulti" title="clojure.core/defmulti
([name docstring? attr-map? dispatch-fn &amp; options])
Macro
  Creates a new multimethod with the associated dispatch function.
  The docstring and attr-map are optional.

  Options are key-value pairs and may be one of:

  :default

  The default dispatch value, defaults to :default

  :hierarchy

  The value used for hierarchical dispatch (e.g. ::square is-a ::shape)

  Hierarchies are type-like relationships that do not depend upon type
  inheritance. By default Clojure's multimethods dispatch off of a
  global hierarchy map.  However, a hierarchy relationship can be
  created with the derive function used to augment the root ancestor
  created with make-hierarchy.

  Multimethods expect the value of the hierarchy option to be supplied as
  a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'
  or the var special form).">defmulti</a> <code>my-mm dispatch-fn)</code></code></td>
              </tr>
              <tr class="even">
                <td>Method define</td>
                <td><code><code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmethod" title="clojure.core/defmethod
([multifn dispatch-val &amp; fn-tail])
Macro
  Creates and installs a new method of multimethod associated with
dispatch-value.">defmethod</a> <code>my-mm :dispatch-value [args] ...)</code></code></td>
              </tr>
              <tr class="odd">
                <td>Dispatch</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/get-method" title="clojure.core/get-method
([multifn dispatch-val])
  Given a multimethod and a dispatch value, returns the dispatch fn
  that would apply to that value, or nil if none apply and no default">get-method</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/methods" title="clojure.core/methods
([multifn])
  Given a multimethod, returns a map of dispatch values -&gt; dispatch fns">methods</a></code></td>
              </tr>
              <tr class="even">
                <td>Remove</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/remove-method" title="clojure.core/remove-method
([multifn dispatch-val])
  Removes the method of multimethod associated with dispatch-value.">remove-method</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove-all-methods" title="clojure.core/remove-all-methods
([multifn])
  Removes all of the methods of multimethod.">remove-all-methods</a></code></td>
              </tr>
              <tr class="odd">
                <td>Prefer</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/prefer-method" title="clojure.core/prefer-method
([multifn dispatch-val-x dispatch-val-y])
  Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y
   when there is a conflict">prefer-method</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/prefers" title="clojure.core/prefers
([multifn])
  Given a multimethod, returns a map of preferred value -&gt; set of other values">prefers</a></code></td>
              </tr>
              <tr class="even">
                <td>Relation</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/derive" title="clojure.core/derive
([tag parent] [h tag parent])
  Establishes a parent/child relationship between parent and
  tag. Parent must be a namespace-qualified symbol or keyword and
  child can be either a namespace-qualified symbol or keyword or a
  class. h must be a hierarchy obtained from make-hierarchy, if not
  supplied defaults to, and modifies, the global hierarchy.">derive</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/underive" title="clojure.core/underive
([tag parent] [h tag parent])
  Removes a parent/child relationship between parent and
  tag. h must be a hierarchy obtained from make-hierarchy, if not
  supplied defaults to, and modifies, the global hierarchy.">underive</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/isa_q" title="clojure.core/isa?
([child parent] [h child parent])
  Returns true if (= child parent), or child is directly or indirectly derived
from
  parent, either via a Java type inheritance relationship or a
  relationship established via derive. h must be a hierarchy obtained
  from make-hierarchy, if not supplied defaults to the global
  hierarchy">isa?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/parents" title="clojure.core/parents
([tag] [h tag])
  Returns the immediate parents of tag, either via a Java type
  inheritance relationship or a relationship established via derive. h
  must be a hierarchy obtained from make-hierarchy, if not supplied
  defaults to the global hierarchy">parents</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ancestors" title="clojure.core/ancestors
([tag] [h tag])
  Returns the immediate and indirect parents of tag, either via a Java type
  inheritance relationship or a relationship established via derive. h
  must be a hierarchy obtained from make-hierarchy, if not supplied
  defaults to the global hierarchy">ancestors</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/descendants" title="clojure.core/descendants
([tag] [h tag])
  Returns the immediate and indirect children of tag, through a
  relationship established via derive. h must be a hierarchy obtained
  from make-hierarchy, if not supplied defaults to the global
  hierarchy. Note: does not work on Java type inheritance
  relationships.">descendants</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/make-hierarchy" title="clojure.core/make-hierarchy
([])
  Creates a hierarchy object for use with derive, isa? etc.">make-hierarchy</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Datafy (<a href="https://corfield.org/blog/2018/12/03/datafy-nav">article</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Datafy</td>
                <td><code>(clojure.datafy/) <a href="https://clojure.github.io/clojure/clojure.datafy-api.html#clojure.datafy/datafy" title="clojure.datafy/datafy
([x])
  Attempts to return x as data.
  datafy will return the value of clojure.core.protocols/datafy. If
  the value has been transformed and the result supports
  metadata, :clojure.datafy/obj will be set on the metadata to the
  original value of x, and :clojure.datafy/class to the name of the
  class of x, as a symbol.">datafy</a> <a href="https://clojure.github.io/clojure/clojure.datafy-api.html#clojure.datafy/nav" title="clojure.datafy/nav
([coll k v])
  Returns (possibly transformed) v in the context of coll and k (a
  key/index or nil). Callers should attempt to provide the key/index
  context k for Indexed/Associative/ILookup colls if possible, but not
  to fabricate one e.g. for sequences (pass nil). nav returns the
  value of clojure.core.protocols/nav.">nav</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Macros</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/defmacro" title="clojure.core/defmacro
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map?
([params*] body) + attr-map?])
Macro
  Like defn, but the resulting function name is declared as a
  macro and will be used as a macro by the compiler when it is
  called.">defmacro</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/definline" title="clojure.core/definline
([name &amp; decl])
Macro
  Experimental - like defmacro, except defines a named function whose
  body is the expansion, calls to which may be expanded inline as if
  it were a macro. Cannot be used with variadic (&amp;) args.">definline</a></code></td>
              </tr>
              <tr class="even">
                <td>Debug</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/macroexpand-1" title="clojure.core/macroexpand-1
([form])
  If form represents a macro form, returns its expansion,
  else returns form.">macroexpand-1</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/macroexpand" title="clojure.core/macroexpand
([form])
  Repeatedly calls macroexpand-1 on form until it no longer
  represents a macro form, then returns it.  Note neither
  macroexpand-1 nor macroexpand expand macros in subforms.">macroexpand</a> (clojure.walk/) <a href="https://clojuredocs.org/clojure_core/clojure.walk/macroexpand-all" title="clojure.walk/macroexpand-all
([form])
  Recursively performs all possible macroexpansions in form.">macroexpand-all</a></code></td>
              </tr>
              <tr class="odd">
                <td>Branch</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/and" title="clojure.core/and
([] [x] [x &amp; next])
Macro
  Evaluates exprs one at a time, from left to right. If a form
  returns logical false (nil or false), and returns that value and
  doesn't evaluate any of the other expressions, otherwise it returns
  the value of the last expr. (and) returns true.">and</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/or" title="clojure.core/or
([] [x] [x &amp; next])
Macro
  Evaluates exprs one at a time, from left to right. If a form
  returns a logical true value, or returns that value and doesn't
  evaluate any of the other expressions, otherwise it returns the
  value of the last expression. (or) returns nil.">or</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when" title="clojure.core/when
([test &amp; body])
Macro
  Evaluates test. If logical true, evaluates body in an implicit do.">when</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-not" title="clojure.core/when-not
([test &amp; body])
Macro
  Evaluates test. If logical false, evaluates body in an implicit do.">when-not</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-let" title="clojure.core/when-let
([bindings &amp; body])
Macro
  bindings =&gt; binding-form test

  When test is true, evaluates body with binding-form bound to the value of test
Spec
  args: (cat :bindings (and vector? :clojure.core.specs.alpha/binding) :body (*
any?))
  ret: any?">when-let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-first" title="clojure.core/when-first
([bindings &amp; body])
Macro
  bindings =&gt; x xs

  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is
evaluated only once">when-first</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if-not" title="clojure.core/if-not
([test then] [test then else])
Macro
  Evaluates test. If logical false, evaluates and returns then expr,
  otherwise else expr, if supplied, else nil.">if-not</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if-let" title="clojure.core/if-let
([bindings then] [bindings then else &amp; oldform])
Macro
  bindings =&gt; binding-form test

  If test is true, evaluates then with binding-form bound to the value of
  test, if not, yields else
Spec
  args: (cat :bindings (and vector? :clojure.core.specs.alpha/binding) :then
any? :else (? any?))
  ret: any?">if-let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cond" title="clojure.core/cond
([&amp; clauses])
Macro
  Takes a set of test/expr pairs. It evaluates each test one at a
  time.  If a test returns logical true, cond evaluates and returns
  the value of the corresponding expr and doesn't evaluate any of the
  other tests or exprs. (cond) returns nil.">cond</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/condp" title="clojure.core/condp
([pred expr &amp; clauses])
Macro
  Takes a binary predicate, an expression, and a set of clauses.
  Each clause can take the form of either:

  test-expr result-expr

  test-expr :&gt;&gt; result-fn

  Note :&gt;&gt; is an ordinary keyword.

  For each clause, (pred test-expr expr) is evaluated. If it returns
  logical true, the clause is a match. If a binary clause matches, the
  result-expr is returned, if a ternary clause matches, its result-fn,
  which must be a unary function, is called with the result of the
  predicate as its argument, the result of that call being the return
  value of condp. A single default expression can follow the clauses,
  and its value will be returned if no clause matches. If no default
  expression is provided and no clause matches, an
  IllegalArgumentException is thrown.">condp</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/case" title="clojure.core/case
([e &amp; clauses])
Macro
  Takes an expression, and a set of clauses.

  Each clause can take the form of either:

  test-constant result-expr

  (test-constant1 ... test-constantN)  result-expr

  The test-constants are not evaluated. They must be compile-time
  literals, and need not be quoted.  If the expression is equal to a
  test-constant, the corresponding result-expr is returned. A single
  default expression can follow the clauses, and its value will be
  returned if no clause matches. If no default expression is provided
  and no clause matches, an IllegalArgumentException is thrown.

  Unlike cond and condp, case does a constant-time dispatch, the
  clauses are not considered sequentially.  All manner of constant
  expressions are acceptable in case, including numbers, strings,
  symbols, keywords, and (Clojure) composites thereof. Note that since
  lists are used to group multiple constants that map to the same
  expression, a vector can be used to match a list if needed. The
  test-constants need not be all of the same type.">case</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-some" title="clojure.core/when-some
([bindings &amp; body])
Macro
  bindings =&gt; binding-form test

   When test is not nil, evaluates body with binding-form bound to the
   value of test">when-some</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if-some" title="clojure.core/if-some
([bindings then] [bindings then else &amp; oldform])
Macro
  bindings =&gt; binding-form test

   If test is not nil, evaluates then with binding-form bound to the
   value of test, if not, yields else">if-some</a></code></td>
              </tr>
              <tr class="even">
                <td>Loop</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doseq" title="clojure.core/doseq
([seq-exprs &amp; body])
Macro
  Repeatedly executes body (presumably for side-effects) with
  bindings and filtering as provided by &quot;for&quot;.  Does not retain
  the head of the sequence. Returns nil.">doseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dotimes" title="clojure.core/dotimes
([bindings &amp; body])
Macro
  bindings =&gt; name n

  Repeatedly executes body (presumably for side-effects) with name
  bound to integers from 0 through n-1.">dotimes</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/while" title="clojure.core/while
([test &amp; body])
Macro
  Repeatedly executes body while test expression is true. Presumes
  some side-effect will cause test to become false/nil. Returns nil">while</a></code></td>
              </tr>
              <tr class="odd">
                <td>Arrange</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/_dot_dot" title="clojure.core/..
([x form] [x form &amp; more])
Macro
  form =&gt; fieldName-symbol or (instanceMethodName-symbol args*)

  Expands into a member access (.) of the first member on the first
  argument, followed by the next member on the result, etc. For
  instance:

  (.. System (getProperties) (get &quot;os.name&quot;))

  expands to:

  (. (. System (getProperties)) (get &quot;os.name&quot;))

  but is easier to write, read, and understand.">..</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doto" title="clojure.core/doto
([x &amp; forms])
Macro
  Evaluates x then calls all of the methods and functions with the
  value of x supplied at the front of the given arguments.  The forms
  are evaluated in order.  Returns x.

  (doto (new java.util.HashMap) (.put &quot;a&quot; 1) (.put &quot;b&quot; 2))">doto</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E" title="clojure.core/-&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  second item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  second item in second form, etc.">-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E%3E" title="clojure.core/-&gt;&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  last item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  last item in second form, etc.">-&gt;&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/as-%3E" title="clojure.core/as-&gt;
([expr name &amp; forms])
Macro
  Binds name to expr, evaluates the first form in the lexical context
  of that binding, then binds name to that result, repeating for each
  successive form, returning the result of the last form.">as-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cond-%3E" title="clojure.core/cond-&gt;
([expr &amp; clauses])
Macro
  Takes an expression and a set of test/form pairs. Threads expr (via -&gt;)
  through each form for which the corresponding test
  expression is true. Note that, unlike cond branching, cond-&gt; threading does
  not short circuit after the first true test expression.">cond-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cond-%3E%3E" title="clojure.core/cond-&gt;&gt;
([expr &amp; clauses])
Macro
  Takes an expression and a set of test/form pairs. Threads expr (via -&gt;&gt;)
  through each form for which the corresponding test expression
  is true.  Note that, unlike cond branching, cond-&gt;&gt; threading does not short
circuit
  after the first true test expression.">cond-&gt;&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some-%3E" title="clojure.core/some-&gt;
([expr &amp; forms])
Macro
  When expr is not nil, threads it into the first form (via -&gt;),
  and when that result is not nil, through the next etc">some-&gt;</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/some-%3E%3E" title="clojure.core/some-&gt;&gt;
([expr &amp; forms])
Macro
  When expr is not nil, threads it into the first form (via -&gt;&gt;),
  and when that result is not nil, through the next etc">some-&gt;&gt;</a></code></td>
              </tr>
              <tr class="even">
                <td>Scope</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/binding" title="clojure.core/binding
([bindings &amp; body])
Macro
  binding =&gt; var-symbol init-expr

  Creates new bindings for the (already-existing) vars, with the
  supplied initial values, executes the exprs in an implicit do, then
  re-establishes the bindings that existed before.  The new bindings
  are made in parallel (unlike let); all init-exprs are evaluated
  before the vars are bound to their new values.">binding</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/locking" title="clojure.core/locking
([x &amp; body])
Macro
  Executes exprs in an implicit do, while holding the monitor of x.
  Will release the monitor of x in all circumstances.">locking</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/time" title="clojure.core/time
([expr])
Macro
  Evaluates expr and prints the time it took.  Returns the value of
 expr.">time</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-in-str" title="clojure.core/with-in-str
([s &amp; body])
Macro
  Evaluates body in a context in which *in* is bound to a fresh
  StringReader initialized with the string s.">with-in-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-local-vars" title="clojure.core/with-local-vars
([name-vals-vec &amp; body])
Macro
  varbinding=&gt; symbol init-expr

  Executes the exprs in a context in which the symbols are bound to
  vars with per-thread bindings to the init-exprs.  The symbols refer
  to the var objects themselves, and must be accessed with var-get and
  var-set">with-local-vars</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-open" title="clojure.core/with-open
([bindings &amp; body])
Macro
  bindings =&gt; [name init ...]

  Evaluates body in a try expression with names bound to the values
  of the inits, and a finally clause that calls (.close name) on each
  name in reverse order.">with-open</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-out-str" title="clojure.core/with-out-str
([&amp; body])
Macro
  Evaluates exprs in a context in which *out* is bound to a fresh
  StringWriter.  Returns the string created by any nested printing
  calls.">with-out-str</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-precision" title="clojure.core/with-precision
([precision &amp; exprs])
Macro
  Sets the precision and rounding mode to be used for BigDecimal operations.

  Usage: (with-precision 10 (/ 1M 3))
  or:    (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.">with-precision</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-redefs" title="clojure.core/with-redefs
([bindings &amp; body])
Macro
  binding =&gt; var-symbol temp-value-expr

  Temporarily redefines Vars while executing the body.  The
  temp-value-exprs will be evaluated and each resulting value will
  replace in parallel the root value of its Var.  After the body is
  executed, the root values of all the Vars will be set back to their
  old values.  These temporary changes will be visible in all threads.
  Useful for mocking out functions during testing.">with-redefs</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-redefs-fn" title="clojure.core/with-redefs-fn
([binding-map func])
  Temporarily redefines Vars during a call to func.  Each val of
  binding-map will replace the root value of its key which must be
  a Var.  After func is called with no args, the root values of all
  the Vars will be set back to their old values.  These temporary
  changes will be visible in all threads.  Useful for mocking out
  functions during testing.">with-redefs-fn</a></code></td>
              </tr>
              <tr class="odd">
                <td>Lazy</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/lazy-cat" title="clojure.core/lazy-cat
([&amp; colls])
Macro
  Expands to code which yields a lazy sequence of the concatenation
  of the supplied colls.  Each coll expr is not evaluated until it is
  needed.

  (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))">lazy-cat</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/lazy-seq" title="clojure.core/lazy-seq
([&amp; body])
Macro
  Takes a body of expressions that returns an ISeq or nil, and yields
  a Seqable object that will invoke the body only the first time seq
  is called, and will cache the result and return it on all subsequent
  seq calls. See also - realized?">lazy-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/delay" title="clojure.core/delay
([&amp; body])
Macro
  Takes a body of expressions and yields a Delay object that will
  invoke the body only the first time it is forced (with force or deref/@), and
  will cache the result and return it on all subsequent force
  calls. See also - realized?">delay</a></code></td>
              </tr>
              <tr class="even">
                <td>Doc.</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/assert" title="clojure.core/assert
([x] [x message])
Macro
  Evaluates expr and throws an exception if it does not evaluate to
  logical true.">assert</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/comment" title="clojure.core/comment
([&amp; body])
Macro
  Ignores body, yields nil">comment</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/doc" title="clojure.repl/doc
([name])
Macro
  Prints documentation for a var or special form given its name,
   or for a spec if given a keyword">doc</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Special Characters (<a href="https://clojure.org/reference/reader#macrochars">clojure.org/reference/reader</a>, <a href="https://clojure.org/guides/weird_characters">guide</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td><code>,</code></td>
                <td>Comma reads as white space.  Often used between map key/value pairs for readability.</td>
              </tr>
              <tr class="even">
                <td><code>'</code></td>
                <td><code><a href="https://clojure.org/reference/reader#_quote">quote</a>: <code>'<var>form</var></code> &rarr; <code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/quote" title="quote
  (quote form)
Special Form
  Yields the unevaluated form.

  Please see http://clojure.org/special_forms#quote">quote</a> <code><var>form</var>)</code></code></td>
              </tr>
              <tr class="odd">
                <td><code>/</code></td>
                <td>Namespace separator (see Primitives/Other section)</td>
              </tr>
              <tr class="even">
                <td><code>\</code></td>
                <td>Character literal (see Primitives/Other section)</td>
              </tr>
              <tr class="odd">
                <td><code>:</code></td>
                <td>Keyword (see Primitives/Other section)</td>
              </tr>
              <tr class="even">
                <td><code>;</code></td>
                <td>Single line comment</td>
              </tr>
              <tr class="odd">
                <td><code>^</code></td>
                <td>Metadata (see Metadata section)</td>
              </tr>
              <tr class="even">
                <td><code>*foo*</code></td>
                <td><code>'earmuffs' - convention to indicate <a href="https://clojure.org/reference/vars">dynamic vars</a>, compiler warns if not dynamic</code></td>
              </tr>
              <tr class="odd">
                <td><code>@</code></td>
                <td><code>Deref: <code>@<var>form</var></code> &rarr; <code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/deref" title="clojure.core/deref
([ref] [ref timeout-ms timeout-val])
  Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a
transaction,
  returns the in-transaction-value of ref, else returns the
  most-recently-committed value of ref. When applied to a var, agent
  or atom, returns its current state. When applied to a delay, forces
  it if not already forced. When applied to a future, will block if
  computation not complete. When applied to a promise, will block
  until a value is delivered.  The variant taking a timeout can be
  used for blocking references (futures and promises), and will return
  timeout-val if the timeout (in milliseconds) is reached before a
  value is available. See also - realized?.">deref</a> <code><var>form</var>)</code></code></td>
              </tr>
              <tr class="even">
                <td><code>`</code></td>
                <td><code><a href="https://clojure.org/reference/reader#syntax-quote">Syntax-quote</a></code></td>
              </tr>
              <tr class="odd">
                <td><code>foo#</code></td>
                <td><code><a href="https://clojure.org/reference/reader#syntax-quote">'auto-gensym'</a>, consistently replaced with same auto-generated symbol everywhere inside same <code>`( ... )</code></code></td>
              </tr>
              <tr class="even">
                <td><code>~</code></td>
                <td><code><a href="https://clojure.org/reference/reader#syntax-quote">Unquote</a></code></td>
              </tr>
              <tr class="odd">
                <td><code>~@</code></td>
                <td><code><a href="https://clojure.org/reference/reader#syntax-quote">Unquote-splicing</a></code></td>
              </tr>
              <tr class="even">
                <td><code>-></code></td>
                <td><code>'thread first' macro <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E" title="clojure.core/-&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  second item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  second item in second form, etc.">-&gt;</a></code></td>
              </tr>
              <tr class="odd">
                <td><code>->></code></td>
                <td><code>'thread last' macro <a href="https://clojuredocs.org/clojure_core/clojure.core/-%3E%3E" title="clojure.core/-&gt;&gt;
([x &amp; forms])
Macro
  Threads the expr through the forms. Inserts x as the
  last item in the first form, making a list of it if it is not a
  list already. If there are more forms, inserts the first form as the
  last item in second form, etc.">-&gt;&gt;</a></code></td>
              </tr>
              <tr class="even">
                <td><code>&gt;!! &lt;!! &gt;! &lt;!</code></td>
                <td><code><a href="https://clojure.org/guides/weird_characters#__code_code_code_code_code_code_and_code_code_core_async_channel_macros">core.async channel macros</a> <a href="https://github.com/clojure/core.async" title="clojure.core.async/&gt;!!
([port val])
  puts a val into port. nil values are not allowed. Will block if no
  buffer space is available. Returns true unless port is already closed.
  Not intended for use in direct or transitive calls from (go ...) blocks.
  Use the clojure.core.async.go-checking flag to detect invalid use (see
  namespace docs).">&gt;!!</a> <a href="https://github.com/clojure/core.async" title="clojure.core.async/&lt;!!
([port])
  takes a val from port. Will return nil if closed. Will block
  if nothing is available.
  Not intended for use in direct or transitive calls from (go ...) blocks.
  Use the clojure.core.async.go-checking flag to detect invalid use (see
  namespace docs).">&lt;!!</a> <a href="https://github.com/clojure/core.async" title="clojure.core.async/&gt;!
([port val])
  puts a val into port. nil values are not allowed. Must be called
  inside a (go ...) block. Will park if no buffer space is available.
  Returns true unless port is already closed.">&gt;!</a> <a href="https://github.com/clojure/core.async" title="clojure.core.async/&lt;!
([port])
  takes a val from port. Must be called inside a (go ...) block. Will
  return nil if closed. Will park if nothing is available.">&lt;!</a></code></td>
              </tr>
              <tr class="odd">
                <td><code>(</code></td>
                <td>List literal (see Collections/Lists section)</td>
              </tr>
              <tr class="even">
                <td><code>[</code></td>
                <td>Vector literal (see Collections/Vectors section)</td>
              </tr>
              <tr class="odd">
                <td><code>{</code></td>
                <td>Map literal (see Collections/Maps section)</td>
              </tr>
              <tr class="even">
                <td><code>#'</code></td>
                <td><code>Var-quote: <code>#'<var>x</var></code> &rarr; <code>(</code> <a href="https://clojuredocs.org/clojure_core/clojure.core/var" title="var
  (var symbol)
Special Form
  The symbol must resolve to a var, and the Var object
itself (not its value) is returned. The reader macro #'x expands to (var x).

  Please see http://clojure.org/special_forms#var">var</a> <code><var>x</var>)</code></code></td>
              </tr>
              <tr class="odd">
                <td><code>#"</code></td>
                <td><code>#"<var>p</var>"</code> reads as regex pattern <var>p</var> (see Strings/Regex section)</td>
              </tr>
              <tr class="even">
                <td><code>#{</code></td>
                <td>Set literal (see Collections/Sets section)</td>
              </tr>
              <tr class="odd">
                <td><code>#(</code></td>
                <td><code><a href="https://clojure.org/reference/reader#_dispatch">Anonymous function literal</a>: <code>#(...)</code> &rarr; <code>(fn [args] (...))</code></code></td>
              </tr>
              <tr class="even">
                <td><code>%</code></td>
                <td><code><a href="https://clojure.org/reference/reader#_dispatch">Anonymous function argument</a>: <code>%N</code> is value of anonymous function arg <code>N</code>.  <code>%</code> short for <code>%1</code>.  <code>%&</code> for rest args.</code></td>
              </tr>
              <tr class="odd">
                <td><code>#?</code></td>
                <td><code><a href="https://clojure.org/reference/reader#_reader_conditionals">Reader conditional</a>: <code>#?(:clj x :cljs y)</code> reads as <code>x</code> on JVM, <code>y</code> in ClojureScript, nothing elsewhere.  Other keys: <code>:cljr :default</code></code></td>
              </tr>
              <tr class="even">
                <td><code>#?@</code></td>
                <td><code><a href="https://clojure.org/reference/reader#_reader_conditionals">Splicing reader conditional</a>: <code>[1 #?@(:clj [x y] :cljs [w z]) 3]</code> reads as <code>[1 x y 3]</code> on JVM, <code>[1 w z 3]</code> in ClojureScript, <code>[1 3]</code> elsewhere.</code></td>
              </tr>
              <tr class="odd">
                <td><code>#foo</code></td>
                <td><code><a href="https://clojure.org/reference/reader#tagged_literals">tagged literal</a> e.g. <code>#inst</code> <code>#uuid</code></code></td>
              </tr>
              <tr class="even">
                <td><code>#:</code></td>
                <td><code><a href="https://clojure.org/reference/reader#map_namespace_syntax">map namespace syntax</a> e.g. <code>#:foo{:a 1}</code> is equal to <code>{:foo/a 1}</code></code></td>
              </tr>
              <tr class="odd">
                <td><code>##</code></td>
                <td><code>(1.9) symbolic values: <code>##Inf ##-Inf ##NaN<code></code></td>
              </tr>
              <tr class="even">
                <td><code>$</code></td>
                <td><code><code>JavaContainerClass$InnerClass</code></code></td>
              </tr>
              <tr class="odd">
                <td><code>foo?</code></td>
                <td><code>conventional ending for a predicate, e.g.: <a href="https://clojuredocs.org/clojure_core/clojure.core/zero_q" title="clojure.core/zero?
([num])
  Returns true if num is zero, else false">zero?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vector_q" title="clojure.core/vector?
([x])
  Return true if x implements IPersistentVector">vector?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/instance_q" title="clojure.core/instance?
([c x])
  Evaluates x and tests if it is an instance of the class
    c. Returns true or false">instance?</a> (unenforced)</code></td>
              </tr>
              <tr class="even">
                <td><code>foo!</code></td>
                <td><code>conventional ending for an unsafe operation, e.g.: <a href="https://clojuredocs.org/clojure_core/clojure.core/set!" title="set!
  (set! var-symbol expr)
  (set! (. instance-expr instanceFieldName-symbol) expr)
  (set! (. Classname-symbol staticFieldName-symbol) expr)
Special Form
  Used to set thread-local-bound vars, Java object instance
fields, and Java class static fields.

  Please see http://clojure.org/vars#set">set!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/swap%21" title="clojure.core/swap!
([atom f] [atom f x] [atom f x y] [atom f x y &amp; args])
  Atomically swaps the value of atom to be:
  (apply f current-value-of-atom args). Note that f may be called
  multiple times, and thus should be free of side effects.  Returns
  the value that was swapped in.">swap!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/alter-meta%21" title="clojure.core/alter-meta!
([iref f &amp; args])
  Atomically sets the metadata for a namespace/var/ref/agent/atom to be:

  (apply f its-current-meta args)

  f must be free of side-effects">alter-meta!</a> (unenforced)</code></td>
              </tr>
              <tr class="odd">
                <td><code>_</code></td>
                <td><code>conventional name for an unused value (unenforced)</code></td>
              </tr>
              <tr class="even">
                <td><code>#_</code></td>
                <td>Ignore next form</td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Metadata (<a href="https://clojure.org/reference/reader#_metadata">clojure.org/reference/reader</a>, <a href="https://clojure.org/reference/special_forms">special_forms</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>General</td>
                <td><code><code>^{:key1 val1 :key2 val2 ...}</code></code></td>
              </tr>
              <tr class="even">
                <td>Abbrevs</td>
                <td><code><code>^Type</code> &rarr; <code>^{:tag Type}</code><br>
<code>^:key</code> &rarr; <code>^{:key true}</code></code></td>
              </tr>
              <tr class="odd">
                <td>Common</td>
                <td><code><code>^:dynamic ^:private ^:doc ^:const</code></code></td>
              </tr>
              <tr class="even">
                <td>Examples</td>
                <td><code><code>(defn ^:private ^String my-fn ...)</code>  <br> <code>(def ^:dynamic *dyn-var* val)</code></code></td>
              </tr>
              <tr class="odd">
                <td>On Vars</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/meta" title="clojure.core/meta
([obj])
  Returns the metadata of obj, returns nil if there is no metadata.">meta</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/with-meta" title="clojure.core/with-meta
([obj m])
  Returns an object of the same type and value as obj, with
    map m as its metadata.">with-meta</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vary-meta" title="clojure.core/vary-meta
([obj f &amp; args])
  Returns an object of the same type and value as obj, with
  (apply f (meta obj) args) as its metadata.">vary-meta</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/alter-meta%21" title="clojure.core/alter-meta!
([iref f &amp; args])
  Atomically sets the metadata for a namespace/var/ref/agent/atom to be:

  (apply f its-current-meta args)

  f must be free of side-effects">alter-meta!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reset-meta%21" title="clojure.core/reset-meta!
([iref metadata-map])
  Atomically resets the metadata for a namespace/var/ref/agent/atom">reset-meta!</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/doc" title="clojure.repl/doc
([name])
Macro
  Prints documentation for a var or special form given its name,
   or for a spec if given a keyword">doc</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/find-doc" title="clojure.repl/find-doc
([re-string-or-pattern])
  Prints documentation for any var whose documentation or name
 contains a match for re-string-or-pattern">find-doc</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/test" title="clojure.core/test
([v])
  test [v] finds fn at key :test in var metadata and calls it,
  presuming failure will throw exception">test</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
      </div><!-- /column -->
      <div class="column">
        <div class="section">
          <h2>Special Forms (<a href="https://clojure.org/reference/special_forms">clojure.org/reference/special_forms</a>)</h2>
          <div class="single_row">
            <code><a href="https://clojuredocs.org/clojure_core/clojure.core/def" title="def
  (def symbol doc-string? init?)
Special Form
  Creates and interns a global var with the name
  of symbol in the current namespace (*ns*) or locates such a var if
  it already exists.  If init is supplied, it is evaluated, and the
  root binding of the var is set to the resulting value.  If init is
  not supplied, the root binding of the var is unaffected.

  Please see http://clojure.org/special_forms#def">def</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if" title="if
  (if test then else?)
Special Form
  Evaluates test. If not the singular values nil or false,
  evaluates and yields then, otherwise, evaluates and yields else. If
  else is not supplied it defaults to nil.

  Please see http://clojure.org/special_forms#if">if</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/do" title="do
  (do exprs*)
Special Form
  Evaluates the expressions in order and returns the value of
  the last. If no expressions are supplied, returns nil.

  Please see http://clojure.org/special_forms#do">do</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/let" title="clojure.core/let
  (let [bindings*] exprs*)
([bindings &amp; body])
Special Form
  binding =&gt; binding-form init-expr
  binding-form =&gt; name, or destructuring-form
  destructuring-form =&gt; map-destructure-form, or seq-destructure-form

  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein.

  See https://clojure.org/reference/special_forms#binding-forms for
  more information about destructuring.

  Please see http://clojure.org/special_forms#let
Spec
  args: (cat :bindings :clojure.core.specs.alpha/bindings :body (* any?))
  ret: any?">let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/letfn" title="clojure.core/letfn
  (letfn [fnspecs*] exprs*)
([fnspecs &amp; body])
Special Form
  fnspec ==&gt; (fname [params*] exprs) or (fname ([params*] exprs)+)

  Takes a vector of function specs and a body, and generates a set of
  bindings of functions to their names. All of the names are available
  in all of the definitions of the functions, as well as the body.">letfn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/quote" title="quote
  (quote form)
Special Form
  Yields the unevaluated form.

  Please see http://clojure.org/special_forms#quote">quote</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/var" title="var
  (var symbol)
Special Form
  The symbol must resolve to a var, and the Var object
itself (not its value) is returned. The reader macro #'x expands to (var x).

  Please see http://clojure.org/special_forms#var">var</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/fn" title="clojure.core/fn
  (fn name? [params*] exprs*)
  (fn name? ([params*] exprs*) +)
([&amp; sigs])
Special Form
  params =&gt; positional-params*, or positional-params* &amp; rest-param
  positional-param =&gt; binding-form
  rest-param =&gt; binding-form
  binding-form =&gt; name, or destructuring-form

  Defines a function.

  See https://clojure.org/reference/special_forms#fn for more information

  Please see http://clojure.org/special_forms#fn
Spec
  args: (cat :fn-name (? simple-symbol?) :fn-tail (alt :arity-1
:clojure.core.specs.alpha/params+body :arity-n (+ (spec
:clojure.core.specs.alpha/params+body))))
  ret: any?">fn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/loop" title="clojure.core/loop
  (loop [bindings*] exprs*)
([bindings &amp; body])
Special Form
  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein. Acts as a recur target.

  Please see http://clojure.org/special_forms#loop">loop</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/recur" title="recur
  (recur exprs*)
Special Form
  Evaluates the exprs in order, then, in parallel, rebinds
  the bindings of the recursion point to the values of the exprs.
  Execution then jumps back to the recursion point, a loop or fn method.

  Please see http://clojure.org/special_forms#recur">recur</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set!" title="set!
  (set! var-symbol expr)
  (set! (. instance-expr instanceFieldName-symbol) expr)
  (set! (. Classname-symbol staticFieldName-symbol) expr)
Special Form
  Used to set thread-local-bound vars, Java object instance
fields, and Java class static fields.

  Please see http://clojure.org/vars#set">set!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/throw" title="throw
  (throw expr)
Special Form
  The expr is evaluated and thrown, therefore it should
  yield an instance of some derivee of Throwable.

  Please see http://clojure.org/special_forms#throw">throw</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/try" title="try
  (try expr* catch-clause* finally-clause?)
Special Form
  catch-clause =&gt; (catch classname name expr*)
  finally-clause =&gt; (finally expr*)

  Catches and handles Java exceptions.

  Please see http://clojure.org/special_forms#try">try</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/monitor-enter" title="monitor-enter
  (monitor-enter x)
Special Form
  Synchronization primitive that should be avoided
  in user code. Use the 'locking' macro.

  Please see http://clojure.org/special_forms#monitor-enter">monitor-enter</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/monitor-exit" title="monitor-exit
  (monitor-exit x)
Special Form
  Synchronization primitive that should be avoided
  in user code. Use the 'locking' macro.

  Please see http://clojure.org/special_forms#monitor-exit">monitor-exit</a></code>
          </div>
          <table>
            <tbody>
              <tr class="odd">
                <td>Binding Forms / Destructuring</td>
                <td><code>(<a href="https://clojure.org/reference/special_forms#binding-forms">examples</a>) <a href="https://clojuredocs.org/clojure_core/clojure.core/let" title="clojure.core/let
  (let [bindings*] exprs*)
([bindings &amp; body])
Special Form
  binding =&gt; binding-form init-expr
  binding-form =&gt; name, or destructuring-form
  destructuring-form =&gt; map-destructure-form, or seq-destructure-form

  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein.

  See https://clojure.org/reference/special_forms#binding-forms for
  more information about destructuring.

  Please see http://clojure.org/special_forms#let
Spec
  args: (cat :bindings :clojure.core.specs.alpha/bindings :body (* any?))
  ret: any?">let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/fn" title="clojure.core/fn
  (fn name? [params*] exprs*)
  (fn name? ([params*] exprs*) +)
([&amp; sigs])
Special Form
  params =&gt; positional-params*, or positional-params* &amp; rest-param
  positional-param =&gt; binding-form
  rest-param =&gt; binding-form
  binding-form =&gt; name, or destructuring-form

  Defines a function.

  See https://clojure.org/reference/special_forms#fn for more information

  Please see http://clojure.org/special_forms#fn
Spec
  args: (cat :fn-name (? simple-symbol?) :fn-tail (alt :arity-1
:clojure.core.specs.alpha/params+body :arity-n (+ (spec
:clojure.core.specs.alpha/params+body))))
  ret: any?">fn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defn" title="clojure.core/defn
([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string?
attr-map? ([params*] prepost-map? body) + attr-map?])
Macro
  Same as (def name (fn [params* ] exprs*)) or (def
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    to the var metadata. prepost-map defines a map with optional keys
    :pre and :post that contain collections of pre or post conditions.
Spec
  args: (cat :fn-name simple-symbol? :docstring (? string?) :meta (? map?)
:fn-tail (alt :arity-1 :clojure.core.specs.alpha/params+body :arity-n (cat
:bodies (+ (spec :clojure.core.specs.alpha/params+body)) :attr-map (? map?))))
  ret: any?">defn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmacro" title="clojure.core/defmacro
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map?
([params*] body) + attr-map?])
Macro
  Like defn, but the resulting function name is declared as a
  macro and will be used as a macro by the compiler when it is
  called.">defmacro</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/loop" title="clojure.core/loop
  (loop [bindings*] exprs*)
([bindings &amp; body])
Special Form
  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein. Acts as a recur target.

  Please see http://clojure.org/special_forms#loop">loop</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/for" title="clojure.core/for
([seq-exprs body-expr])
Macro
  List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)] [x y]))">for</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doseq" title="clojure.core/doseq
([seq-exprs &amp; body])
Macro
  Repeatedly executes body (presumably for side-effects) with
  bindings and filtering as provided by &quot;for&quot;.  Does not retain
  the head of the sequence. Returns nil.">doseq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if-let" title="clojure.core/if-let
([bindings then] [bindings then else &amp; oldform])
Macro
  bindings =&gt; binding-form test

  If test is true, evaluates then with binding-form bound to the value of
  test, if not, yields else
Spec
  args: (cat :bindings (and vector? :clojure.core.specs.alpha/binding) :then
any? :else (? any?))
  ret: any?">if-let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-let" title="clojure.core/when-let
([bindings &amp; body])
Macro
  bindings =&gt; binding-form test

  When test is true, evaluates body with binding-form bound to the value of test
Spec
  args: (cat :bindings (and vector? :clojure.core.specs.alpha/binding) :body (*
any?))
  ret: any?">when-let</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/if-some" title="clojure.core/if-some
([bindings then] [bindings then else &amp; oldform])
Macro
  bindings =&gt; binding-form test

   If test is not nil, evaluates then with binding-form bound to the
   value of test, if not, yields else">if-some</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/when-some" title="clojure.core/when-some
([bindings &amp; body])
Macro
  bindings =&gt; binding-form test

   When test is not nil, evaluates body with binding-form bound to the
   value of test">when-some</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Vars and global environment (<a href="https://clojure.org/reference/vars">clojure.org/reference/vars</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Def variants</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/def" title="def
  (def symbol doc-string? init?)
Special Form
  Creates and interns a global var with the name
  of symbol in the current namespace (*ns*) or locates such a var if
  it already exists.  If init is supplied, it is evaluated, and the
  root binding of the var is set to the resulting value.  If init is
  not supplied, the root binding of the var is unaffected.

  Please see http://clojure.org/special_forms#def">def</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defn" title="clojure.core/defn
([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string?
attr-map? ([params*] prepost-map? body) + attr-map?])
Macro
  Same as (def name (fn [params* ] exprs*)) or (def
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    to the var metadata. prepost-map defines a map with optional keys
    :pre and :post that contain collections of pre or post conditions.
Spec
  args: (cat :fn-name simple-symbol? :docstring (? string?) :meta (? map?)
:fn-tail (alt :arity-1 :clojure.core.specs.alpha/params+body :arity-n (cat
:bodies (+ (spec :clojure.core.specs.alpha/params+body)) :attr-map (? map?))))
  ret: any?">defn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defn-" title="clojure.core/defn-
([name &amp; decls])
Macro
  same as defn, yielding non-public def
Spec
  args: (cat :fn-name simple-symbol? :docstring (? string?) :meta (? map?)
:fn-tail (alt :arity-1 :clojure.core.specs.alpha/params+body :arity-n (cat
:bodies (+ (spec :clojure.core.specs.alpha/params+body)) :attr-map (? map?))))
  ret: any?">defn-</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/definline" title="clojure.core/definline
([name &amp; decl])
Macro
  Experimental - like defmacro, except defines a named function whose
  body is the expansion, calls to which may be expanded inline as if
  it were a macro. Cannot be used with variadic (&amp;) args.">definline</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmacro" title="clojure.core/defmacro
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map?
([params*] body) + attr-map?])
Macro
  Like defn, but the resulting function name is declared as a
  macro and will be used as a macro by the compiler when it is
  called.">defmacro</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmethod" title="clojure.core/defmethod
([multifn dispatch-val &amp; fn-tail])
Macro
  Creates and installs a new method of multimethod associated with
dispatch-value.">defmethod</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defmulti" title="clojure.core/defmulti
([name docstring? attr-map? dispatch-fn &amp; options])
Macro
  Creates a new multimethod with the associated dispatch function.
  The docstring and attr-map are optional.

  Options are key-value pairs and may be one of:

  :default

  The default dispatch value, defaults to :default

  :hierarchy

  The value used for hierarchical dispatch (e.g. ::square is-a ::shape)

  Hierarchies are type-like relationships that do not depend upon type
  inheritance. By default Clojure's multimethods dispatch off of a
  global hierarchy map.  However, a hierarchy relationship can be
  created with the derive function used to augment the root ancestor
  created with make-hierarchy.

  Multimethods expect the value of the hierarchy option to be supplied as
  a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'
  or the var special form).">defmulti</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defonce" title="clojure.core/defonce
([name expr])
Macro
  defs name to have the root value of the expr iff the named var has no root
value,
  else expr is unevaluated">defonce</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/defrecord" title="clojure.core/defrecord
([name [&amp; fields] &amp; opts+specs])
Macro
  (defrecord name [fields*]  options* specs*)

  Options are expressed as sequential keywords and arguments (in any order).

  Supported options:
  :load-ns - if true, importing the record class will cause the
             namespace in which the record was defined to be loaded.
             Defaults to false.

  Each spec consists of a protocol or interface name followed by zero
  or more method bodies:

  protocol-or-interface-or-Object
  (methodName [args*] body)*

  Dynamically generates compiled bytecode for class with the given
  name, in a package with the same name as the current namespace, the
  given fields, and, optionally, methods for protocols and/or
  interfaces.

  The class will have the (immutable) fields named by
  fields, which can have type hints. Protocols/interfaces and methods

[ documentation truncated.  Click link for the rest. ]">defrecord</a></code></td>
              </tr>
              <tr class="even">
                <td>Interned vars</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/declare" title="clojure.core/declare
([&amp; names])
Macro
  defs the supplied var names with no bindings, useful for making forward
declarations.">declare</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/intern" title="clojure.core/intern
([ns name] [ns name val])
  Finds or creates a var named by the symbol name in the namespace
  ns (which can be a symbol or a namespace), setting its root binding
  to val if supplied. The namespace must exist. The var will adopt any
  metadata from the name symbol.  Returns the var.">intern</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/binding" title="clojure.core/binding
([bindings &amp; body])
Macro
  binding =&gt; var-symbol init-expr

  Creates new bindings for the (already-existing) vars, with the
  supplied initial values, executes the exprs in an implicit do, then
  re-establishes the bindings that existed before.  The new bindings
  are made in parallel (unlike let); all init-exprs are evaluated
  before the vars are bound to their new values.">binding</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/find-var" title="clojure.core/find-var
([sym])
  Returns the global var named by the namespace-qualified symbol, or
  nil if no var with that name.">find-var</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/var" title="var
  (var symbol)
Special Form
  The symbol must resolve to a var, and the Var object
itself (not its value) is returned. The reader macro #'x expands to (var x).

  Please see http://clojure.org/special_forms#var">var</a></code></td>
              </tr>
              <tr class="odd">
                <td>Var objects</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/with-local-vars" title="clojure.core/with-local-vars
([name-vals-vec &amp; body])
Macro
  varbinding=&gt; symbol init-expr

  Executes the exprs in a context in which the symbols are bound to
  vars with per-thread bindings to the init-exprs.  The symbols refer
  to the var objects themselves, and must be accessed with var-get and
  var-set">with-local-vars</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/var-get" title="clojure.core/var-get
([x])
  Gets the value in the var object">var-get</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/var-set" title="clojure.core/var-set
([x val])
  Sets the value in the var object to val. The var must be
 thread-locally bound.">var-set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/alter-var-root" title="clojure.core/alter-var-root
([v f &amp; args])
  Atomically alters the root binding of var v by applying f to its
  current value plus any args">alter-var-root</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/var_q" title="clojure.core/var?
([v])
  Returns true if v is of type clojure.lang.Var">var?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bound_q" title="clojure.core/bound?
([&amp; vars])
  Returns true if all of the vars provided as arguments have any bound value,
root or thread-local.
   Implies that deref'ing the provided vars will succeed. Returns true if no
vars are provided.">bound?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/thread-bound_q" title="clojure.core/thread-bound?
([&amp; vars])
  Returns true if all of the vars provided as arguments have thread-local
bindings.
   Implies that set!'ing the provided vars will succeed.  Returns true if no
vars are provided.">thread-bound?</a></code></td>
              </tr>
              <tr class="even">
                <td>Var validators</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/set-validator%21" title="clojure.core/set-validator!
([iref validator-fn])
  Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
  side-effect-free fn of one argument, which will be passed the intended
  new state on any state change. If the new state is unacceptable, the
  validator-fn should return false or throw an exception. If the current state
(root
  value if var) is not acceptable to the new validator, an exception
  will be thrown and the validator will not be changed.">set-validator!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-validator" title="clojure.core/get-validator
([iref])
  Gets the validator-fn for a var/ref/agent/atom.">get-validator</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Namespace</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Current</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*ns*" title="clojure.core/*ns*
  A clojure.lang.Namespace object representing the current namespace.">*ns*</a></code></td>
              </tr>
              <tr class="even">
                <td>Create/Switch</td>
                <td><code>(<a href="https://blog.8thlight.com/colin-jones/2010/12/05/clojure-libs-and-namespaces-require-use-import-and-ns.html">tutorial</a>) <a href="https://clojuredocs.org/clojure_core/clojure.core/ns" title="clojure.core/ns
([name docstring? attr-map? references*])
Macro
  Sets *ns* to the namespace named by name (unevaluated), creating it
  if needed.  references can be zero or more of: (:refer-clojure ...)
  (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)
  with the syntax of refer-clojure/require/use/import/load/gen-class
  respectively, except the arguments are unevaluated and need not be
  quoted. (:gen-class ...), when supplied, defaults to :name
  corresponding to the ns name, :main true, :impl-ns same as ns, and
  :init-impl-ns true. All options of gen-class are
  supported. The :gen-class directive is ignored when not
  compiling. If :gen-class is not supplied, when compiled only an
  nsname__init.class will be generated. If :refer-clojure is not used, a
  default (refer 'clojure.core) is used.  Use of ns is preferred to
  individual calls to in-ns/require/use/import:

  (ns foo.bar
    (:refer-clojure :exclude [ancestors printf])
    (:require (clojure.contrib sql combinatorics))
    (:use (my.lib this that))
    (:import (java.util Date Timer Random)
             (java.sql Connection Statement)))
Spec
  args: (cat :ns-name simple-symbol? :docstring (? string?) :attr-map (? map?)

[ documentation truncated.  Click link for the rest. ]">ns</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/in-ns" title="clojure.core/in-ns
([name])
  Sets *ns* to the namespace named by the symbol, creating it if needed.">in-ns</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/create-ns" title="clojure.core/create-ns
([sym])
  Create a new namespace named by the symbol if one doesn't already
  exist, returns it or the already-existing namespace of the same
  name.">create-ns</a></code></td>
              </tr>
              <tr class="odd">
                <td>Add</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/alias" title="clojure.core/alias
([alias namespace-sym])
  Add an alias in the current namespace to another
  namespace. Arguments are two symbols: the alias to be used, and
  the symbolic name of the target namespace. Use :as in the ns macro in
preference
  to calling this directly.">alias</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/def" title="def
  (def symbol doc-string? init?)
Special Form
  Creates and interns a global var with the name
  of symbol in the current namespace (*ns*) or locates such a var if
  it already exists.  If init is supplied, it is evaluated, and the
  root binding of the var is set to the resulting value.  If init is
  not supplied, the root binding of the var is unaffected.

  Please see http://clojure.org/special_forms#def">def</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/import" title="clojure.core/import
([&amp; import-symbols-or-lists])
Macro
  import-list =&gt; (package-symbol class-name-symbols*)

  For each name in class-name-symbols, adds a mapping from name to the
  class named by package.name to the current namespace. Use :import in the ns
  macro in preference to calling this directly.
Spec
  args: (* (alt :class (quotable simple-symbol?) :package-list (quotable
:clojure.core.specs.alpha/package-list)))
  ret: any?">import</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/intern" title="clojure.core/intern
([ns name] [ns name val])
  Finds or creates a var named by the symbol name in the namespace
  ns (which can be a symbol or a namespace), setting its root binding
  to val if supplied. The namespace must exist. The var will adopt any
  metadata from the name symbol.  Returns the var.">intern</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/refer" title="clojure.core/refer
([ns-sym &amp; filters])
  refers to all public vars of ns, subject to filters.
  filters can include at most one each of:

  :exclude list-of-symbols
  :only list-of-symbols
  :rename map-of-fromsymbol-tosymbol

  For each public interned var in the namespace named by the symbol,
  adds a mapping from the name of the var to the var to the current
  namespace.  Throws an exception if name is already mapped to
  something else in the current namespace. Filters can be used to
  select a subset, via inclusion or exclusion, or to provide a mapping
  to a symbol different from the var's name, in order to prevent
  clashes. Use :use in the ns macro in preference to calling this directly.">refer</a></code></td>
              </tr>
              <tr class="even">
                <td>Find</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/all-ns" title="clojure.core/all-ns
([])
  Returns a sequence of all namespaces.">all-ns</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/find-ns" title="clojure.core/find-ns
([sym])
  Returns the namespace named by the symbol or nil if it doesn't exist.">find-ns</a></code></td>
              </tr>
              <tr class="odd">
                <td>Examine</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/ns-name" title="clojure.core/ns-name
([ns])
  Returns the name of the namespace, a symbol.">ns-name</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-aliases" title="clojure.core/ns-aliases
([ns])
  Returns a map of the aliases for the namespace.">ns-aliases</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-map" title="clojure.core/ns-map
([ns])
  Returns a map of all the mappings for the namespace.">ns-map</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-interns" title="clojure.core/ns-interns
([ns])
  Returns a map of the intern mappings for the namespace.">ns-interns</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-publics" title="clojure.core/ns-publics
([ns])
  Returns a map of the public intern mappings for the namespace.">ns-publics</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-refers" title="clojure.core/ns-refers
([ns])
  Returns a map of the refer mappings for the namespace.">ns-refers</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-imports" title="clojure.core/ns-imports
([ns])
  Returns a map of the import mappings for the namespace.">ns-imports</a></code></td>
              </tr>
              <tr class="even">
                <td>From symbol</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/resolve" title="clojure.core/resolve
([sym] [env sym])
  same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &amp;env symbol)">resolve</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-resolve" title="clojure.core/ns-resolve
([ns sym] [ns env sym])
  Returns the var or Class to which a symbol will be resolved in the
  namespace (unless found in the environment), else nil.  Note that
  if the symbol is fully qualified, the var/Class to which it resolves
  need not be present in the namespace.">ns-resolve</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/namespace" title="clojure.core/namespace
([x])
  Returns the namespace String of a symbol or keyword, or nil if not present.">namespace</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/the-ns" title="clojure.core/the-ns
([x])
  If passed a namespace, returns it. Else, when passed a symbol,
  returns the namespace named by it, throwing an exception if not
  found.">the-ns</a> (1.10) <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/requiring-resolve" title="clojure.core/requiring-resolve
([sym])
  Resolves namespace-qualified sym per 'resolve'. If initial resolve
fails, attempts to require sym's namespace and retries.">requiring-resolve</a></code></td>
              </tr>
              <tr class="odd">
                <td>Remove</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/ns-unalias" title="clojure.core/ns-unalias
([ns sym])
  Removes the alias for the symbol from the namespace.">ns-unalias</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ns-unmap" title="clojure.core/ns-unmap
([ns sym])
  Removes the mappings for the symbol from the namespace.">ns-unmap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove-ns" title="clojure.core/remove-ns
([sym])
  Removes the namespace named by the symbol. Use with caution.
  Cannot be used to remove the clojure namespace.">remove-ns</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Loading</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Load libs</td>
                <td><code>(<a href="https://blog.8thlight.com/colin-jones/2010/12/05/clojure-libs-and-namespaces-require-use-import-and-ns.html">tutorial</a>) <a href="https://clojuredocs.org/clojure_core/clojure.core/require" title="clojure.core/require
([&amp; args])
  Loads libs, skipping any that are already loaded. Each argument is
  either a libspec that identifies a lib, a prefix list that identifies
  multiple libs whose names share a common prefix, or a flag that modifies
  how all the identified libs are loaded. Use :require in the ns macro
  in preference to calling this directly.

  Libs

  A 'lib' is a named set of resources in classpath whose contents define a
  library of Clojure code. Lib names are symbols and each lib is associated
  with a Clojure namespace and a Java package that share its name. A lib's
  name also locates its root directory within classpath using Java's
  package name to classpath-relative path mapping. All resources in a lib
  should be contained in the directory structure under its root directory.
  All definitions a lib makes should be in its associated namespace.

  'require loads a lib by loading its root resource. The root resource path
  is derived from the lib name in the following manner:
  Consider a lib named by the symbol 'x.y.z; it has the root directory
  &lt;classpath&gt;/x/y/, and its root resource is &lt;classpath&gt;/x/y/z.clj, or
  &lt;classpath&gt;/x/y/z.cljc if &lt;classpath&gt;/x/y/z.clj does not exist. The
  root resource should contain code to create the lib's
  namespace (usually by using the ns macro) and load any additional

[ documentation truncated.  Click link for the rest. ]">require</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/use" title="clojure.core/use
([&amp; args])
  Like 'require, but also refers to each lib's namespace using
  clojure.core/refer. Use :use in the ns macro in preference to calling
  this directly.

  'use accepts additional options in libspecs: :exclude, :only, :rename.
  The arguments and semantics for :exclude, :only, and :rename are the same
  as those documented for clojure.core/refer.">use</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/import" title="clojure.core/import
([&amp; import-symbols-or-lists])
Macro
  import-list =&gt; (package-symbol class-name-symbols*)

  For each name in class-name-symbols, adds a mapping from name to the
  class named by package.name to the current namespace. Use :import in the ns
  macro in preference to calling this directly.
Spec
  args: (* (alt :class (quotable simple-symbol?) :package-list (quotable
:clojure.core.specs.alpha/package-list)))
  ret: any?">import</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/refer" title="clojure.core/refer
([ns-sym &amp; filters])
  refers to all public vars of ns, subject to filters.
  filters can include at most one each of:

  :exclude list-of-symbols
  :only list-of-symbols
  :rename map-of-fromsymbol-tosymbol

  For each public interned var in the namespace named by the symbol,
  adds a mapping from the name of the var to the var to the current
  namespace.  Throws an exception if name is already mapped to
  something else in the current namespace. Filters can be used to
  select a subset, via inclusion or exclusion, or to provide a mapping
  to a symbol different from the var's name, in order to prevent
  clashes. Use :use in the ns macro in preference to calling this directly.">refer</a></code></td>
              </tr>
              <tr class="even">
                <td>List loaded</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/loaded-libs" title="clojure.core/loaded-libs
([])
  Returns a sorted set of symbols naming the currently loaded libs">loaded-libs</a></code></td>
              </tr>
              <tr class="odd">
                <td>Load misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/load" title="clojure.core/load
([&amp; paths])
  Loads Clojure code from resources in classpath. A path is interpreted as
  classpath-relative if it begins with a slash or relative to the root
  directory for the current namespace otherwise.">load</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/load-file" title="clojure.core/load-file
([name])
  Sequentially read and evaluate the set of forms contained in the file.">load-file</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/load-reader" title="clojure.core/load-reader
([rdr])
  Sequentially read and evaluate the set of forms contained in the
  stream/file">load-reader</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/load-string" title="clojure.core/load-string
([s])
  Sequentially read and evaluate the set of forms contained in the
  string">load-string</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Concurrency</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>Atoms</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/atom" title="clojure.core/atom
([x] [x &amp; options])
  Creates and returns an Atom with an initial value of x and zero or
  more options (in any order):

  :meta metadata-map

  :validator validate-fn

  If metadata-map is supplied, it will become the metadata on the
  atom. validate-fn must be nil or a side-effect-free fn of one
  argument, which will be passed the intended new state on any state
  change. If the new state is unacceptable, the validate-fn should
  return false or throw an exception.">atom</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/swap%21" title="clojure.core/swap!
([atom f] [atom f x] [atom f x y] [atom f x y &amp; args])
  Atomically swaps the value of atom to be:
  (apply f current-value-of-atom args). Note that f may be called
  multiple times, and thus should be free of side effects.  Returns
  the value that was swapped in.">swap!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reset%21" title="clojure.core/reset!
([atom newval])
  Sets the value of atom to newval without regard for the
  current value. Returns newval.">reset!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compare-and-set%21" title="clojure.core/compare-and-set!
([atom oldval newval])
  Atomically sets the value of atom to newval if and only if the
  current value of the atom is identical to oldval. Returns true if
  set happened, else false">compare-and-set!</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/swap-vals%21" title="clojure.core/swap-vals!
([atom f] [atom f x] [atom f x y] [atom f x y &amp; args])
  Atomically swaps the value of atom to be:
  (apply f current-value-of-atom args). Note that f may be called
  multiple times, and thus should be free of side effects.
  Returns [old new], the value of the atom before and after the swap.">swap-vals!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/reset-vals%21" title="clojure.core/reset-vals!
([atom newval])
  Sets the value of atom to newval. Returns [old new], the value of the
   atom before and after the reset.">reset-vals!</a></code></td>
              </tr>
              <tr class="even">
                <td>Futures</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/future" title="clojure.core/future
([&amp; body])
Macro
  Takes a body of expressions and yields a future object that will
  invoke the body in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block, unless the variant of
  deref with timeout is used. See also - realized?.">future</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/future-call" title="clojure.core/future-call
([f])
  Takes a function of no args and yields a future object that will
  invoke the function in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block, unless the variant
  of deref with timeout is used. See also - realized?.">future-call</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/future-done_q" title="clojure.core/future-done?
([f])
  Returns true if future f is done">future-done?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/future-cancel" title="clojure.core/future-cancel
([f])
  Cancels the future, if possible.">future-cancel</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/future-cancelled_q" title="clojure.core/future-cancelled?
([f])
  Returns true if future f is cancelled">future-cancelled?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/future_q" title="clojure.core/future?
([x])
  Returns true if x is a future">future?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Threads</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/bound-fn" title="clojure.core/bound-fn
([&amp; fntail])
Macro
  Returns a function defined by the given fntail, which will install the
  same bindings in effect as in the thread at the time bound-fn was called.
  This may be used to define a helper function which runs on a different
  thread, but needs the same bindings in place.">bound-fn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bound-fn*" title="clojure.core/bound-fn*
([f])
  Returns a function, which will install the same bindings in effect as in
  the thread at the time bound-fn* was called and then call f with any given
  arguments. This may be used to define a helper function which runs on a
  different thread, but needs the same bindings in place.">bound-fn*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-thread-bindings" title="clojure.core/get-thread-bindings
([])
  Get a map with the Var/value pairs which is currently in effect for the
  current thread.">get-thread-bindings</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/push-thread-bindings" title="clojure.core/push-thread-bindings
([bindings])
  WARNING: This is a low-level function. Prefer high-level macros like
  binding where ever possible.

  Takes a map of Var/value pairs. Binds each Var to the associated value for
  the current thread. Each call *MUST* be accompanied by a matching call to
  pop-thread-bindings wrapped in a try-finally!

      (push-thread-bindings bindings)
      (try
        ...
        (finally
          (pop-thread-bindings)))">push-thread-bindings</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pop-thread-bindings" title="clojure.core/pop-thread-bindings
([])
  Pop one set of bindings pushed with push-binding before. It is an error to
  pop bindings without pushing before.">pop-thread-bindings</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/thread-bound_q" title="clojure.core/thread-bound?
([&amp; vars])
  Returns true if all of the vars provided as arguments have thread-local
bindings.
   Implies that set!'ing the provided vars will succeed.  Returns true if no
vars are provided.">thread-bound?</a></code></td>
              </tr>
              <tr class="even">
                <td>Volatiles</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/volatile%21" title="clojure.core/volatile!
([val])
  Creates and returns a Volatile with an initial value of val.">volatile!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vreset%21" title="clojure.core/vreset!
([vol newval])
  Sets the value of volatile to newval without regard for the
   current value. Returns newval.">vreset!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/vswap%21" title="clojure.core/vswap!
([vol f &amp; args])
Macro
  Non-atomically swaps the value of the volatile as if:
   (apply f current-value-of-vol args). Returns the value that
   was swapped in.">vswap!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/volatile_q" title="clojure.core/volatile?
([x])
  Returns true if x is a volatile.">volatile?</a></code></td>
              </tr>
              <tr class="odd">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/locking" title="clojure.core/locking
([x &amp; body])
Macro
  Executes exprs in an implicit do, while holding the monitor of x.
  Will release the monitor of x in all circumstances.">locking</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pcalls" title="clojure.core/pcalls
([&amp; fns])
  Executes the no-arg fns in parallel, returning a lazy sequence of
  their values">pcalls</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pvalues" title="clojure.core/pvalues
([&amp; exprs])
Macro
  Returns a lazy sequence of the values of the exprs, which are
  evaluated in parallel">pvalues</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/pmap" title="clojure.core/pmap
([f coll] [f coll &amp; colls])
  Like map, except f is applied in parallel. Semi-lazy in that the
  parallel computation stays ahead of the consumption, but doesn't
  realize the entire result unless required. Only useful for
  computationally intensive functions where the time of f dominates
  the coordination overhead.">pmap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/seque" title="clojure.core/seque
([s] [n-or-q s])
  Creates a queued seq on another (presumably lazy) seq s. The queued
  seq will produce a concrete seq in the background, and can get up to
  n items ahead of the consumer. n-or-q can be an integer n buffer
  size, or an instance of java.util.concurrent BlockingQueue. Note
  that reading from a seque can block if the reader gets ahead of the
  producer.">seque</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/promise" title="clojure.core/promise
([])
  Returns a promise object that can be read with deref/@, and set,
  once only, with deliver. Calls to deref/@ prior to delivery will
  block, unless the variant of deref with timeout is used. All
  subsequent derefs will return the same delivered value without
  blocking. See also - realized?.">promise</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/deliver" title="clojure.core/deliver
([promise val])
  Delivers the supplied value to the promise, releasing any pending
  derefs. A subsequent call to deliver on a promise will have no effect.">deliver</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Refs and Transactions (<a href="https://clojure.org/reference/refs">clojure.org/reference/refs</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/ref" title="clojure.core/ref
([x] [x &amp; options])
  Creates and returns a Ref with an initial value of x and zero or
  more options (in any order):

  :meta metadata-map

  :validator validate-fn

  :min-history (default 0)
  :max-history (default 10)

  If metadata-map is supplied, it will become the metadata on the
  ref. validate-fn must be nil or a side-effect-free fn of one
  argument, which will be passed the intended new state on any state
  change. If the new state is unacceptable, the validate-fn should
  return false or throw an exception. validate-fn will be called on
  transaction commit, when all refs have their final values.

  Normally refs accumulate history dynamically as needed to deal with
  read demands. If you know in advance you will need history you can
  set :min-history to ensure it will be available when first needed (instead
  of after a read fault). History is limited, and the limit can be set
  with :max-history.">ref</a></code></td>
              </tr>
              <tr class="even">
                <td>Examine</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/deref" title="clojure.core/deref
([ref] [ref timeout-ms timeout-val])
  Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a
transaction,
  returns the in-transaction-value of ref, else returns the
  most-recently-committed value of ref. When applied to a var, agent
  or atom, returns its current state. When applied to a delay, forces
  it if not already forced. When applied to a future, will block if
  computation not complete. When applied to a promise, will block
  until a value is delivered.  The variant taking a timeout can be
  used for blocking references (futures and promises), and will return
  timeout-val if the timeout (in milliseconds) is reached before a
  value is available. See also - realized?.">deref</a> @ (<code>@<var>form</var></code> &rarr; <code>(deref <var>form</var>)</code>)</code></td>
              </tr>
              <tr class="odd">
                <td>Transaction</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/sync" title="clojure.core/sync
([flags-ignored-for-now &amp; body])
Macro
  transaction-flags =&gt; TBD, pass nil for now

  Runs the exprs (in an implicit do) in a transaction that encompasses
  exprs and any nested calls.  Starts a transaction if none is already
  running on this thread. Any uncaught exception will abort the
  transaction and flow out of sync. The exprs may be run more than
  once, but any effects on Refs will be atomic.">sync</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/dosync" title="clojure.core/dosync
([&amp; exprs])
Macro
  Runs the exprs (in an implicit do) in a transaction that encompasses
  exprs and any nested calls.  Starts a transaction if none is already
  running on this thread. Any uncaught exception will abort the
  transaction and flow out of dosync. The exprs may be run more than
  once, but any effects on Refs will be atomic.">dosync</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/io%21" title="clojure.core/io!
([&amp; body])
Macro
  If an io! block occurs in a transaction, throws an
  IllegalStateException, else runs body in an implicit do. If the
  first expression in body is a literal string, will use that as the
  exception message.">io!</a></code></td>
              </tr>
              <tr class="even">
                <td>In transaction</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/ensure" title="clojure.core/ensure
([ref])
  Must be called in a transaction. Protects the ref from modification
  by other transactions.  Returns the in-transaction-value of
  ref. Allows for more concurrency than (ref-set ref @ref)">ensure</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ref-set" title="clojure.core/ref-set
([ref val])
  Must be called in a transaction. Sets the value of ref.
  Returns val.">ref-set</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/alter" title="clojure.core/alter
([ref fun &amp; args])
  Must be called in a transaction. Sets the in-transaction-value of
  ref to:

  (apply fun in-transaction-value-of-ref args)

  and returns the in-transaction-value of ref.">alter</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/commute" title="clojure.core/commute
([ref fun &amp; args])
  Must be called in a transaction. Sets the in-transaction-value of
  ref to:

  (apply fun in-transaction-value-of-ref args)

  and returns the in-transaction-value of ref.

  At the commit point of the transaction, sets the value of ref to be:

  (apply fun most-recently-committed-value-of-ref args)

  Thus fun should be commutative, or, failing that, you must accept
  last-one-in-wins behavior.  commute allows for more concurrency than
  ref-set.">commute</a></code></td>
              </tr>
              <tr class="odd">
                <td>Validators</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/set-validator%21" title="clojure.core/set-validator!
([iref validator-fn])
  Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
  side-effect-free fn of one argument, which will be passed the intended
  new state on any state change. If the new state is unacceptable, the
  validator-fn should return false or throw an exception. If the current state
(root
  value if var) is not acceptable to the new validator, an exception
  will be thrown and the validator will not be changed.">set-validator!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-validator" title="clojure.core/get-validator
([iref])
  Gets the validator-fn for a var/ref/agent/atom.">get-validator</a></code></td>
              </tr>
              <tr class="even">
                <td>History</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/ref-history-count" title="clojure.core/ref-history-count
([ref])
  Returns the history count of a ref">ref-history-count</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ref-min-history" title="clojure.core/ref-min-history
([ref] [ref n])
  Gets the min-history of a ref, or sets it and returns the ref">ref-min-history</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ref-max-history" title="clojure.core/ref-max-history
([ref] [ref n])
  Gets the max-history of a ref, or sets it and returns the ref">ref-max-history</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Agents and Asynchronous Actions (<a href="https://clojure.org/reference/agents">clojure.org/reference/agents</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/agent" title="clojure.core/agent
([state &amp; options])
  Creates and returns an agent with an initial value of state and
  zero or more options (in any order):

  :meta metadata-map

  :validator validate-fn

  :error-handler handler-fn

  :error-mode mode-keyword

  If metadata-map is supplied, it will become the metadata on the
  agent. validate-fn must be nil or a side-effect-free fn of one
  argument, which will be passed the intended new state on any state
  change. If the new state is unacceptable, the validate-fn should
  return false or throw an exception.  handler-fn is called if an
  action throws an exception or if validate-fn rejects a new state --
  see set-error-handler! for details.  The mode-keyword may be either
  :continue (the default if an error-handler is given) or :fail (the
  default if no error-handler is given) -- see set-error-mode! for
  details.">agent</a></code></td>
              </tr>
              <tr class="even">
                <td>Examine</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/agent-error" title="clojure.core/agent-error
([a])
  Returns the exception thrown during an asynchronous action of the
  agent if the agent is failed.  Returns nil if the agent is not
  failed.">agent-error</a></code></td>
              </tr>
              <tr class="odd">
                <td>Change state</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/send" title="clojure.core/send
([a f &amp; args])
  Dispatch an action to an agent. Returns the agent immediately.
  Subsequently, in a thread from a thread pool, the state of the agent
  will be set to the value of:

  (apply action-fn state-of-agent args)">send</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/send-off" title="clojure.core/send-off
([a f &amp; args])
  Dispatch a potentially blocking action to an agent. Returns the
  agent immediately. Subsequently, in a separate thread, the state of
  the agent will be set to the value of:

  (apply action-fn state-of-agent args)">send-off</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/restart-agent" title="clojure.core/restart-agent
([a new-state &amp; options])
  When an agent is failed, changes the agent state to new-state and
  then un-fails the agent so that sends are allowed again.  If
  a :clear-actions true option is given, any actions queued on the
  agent that were being held while it was failed will be discarded,
  otherwise those held actions will proceed.  The new-state must pass
  the validator if any, or restart will throw an exception and the
  agent will remain failed with its old state and error.  Watchers, if
  any, will NOT be notified of the new state.  Throws an exception if
  the agent is not failed.">restart-agent</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/send-via" title="clojure.core/send-via
([executor a f &amp; args])
  Dispatch an action to an agent. Returns the agent immediately.
  Subsequently, in a thread supplied by executor, the state of the agent
  will be set to the value of:

  (apply action-fn state-of-agent args)">send-via</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set-agent-send-executor%21" title="clojure.core/set-agent-send-executor!
([executor])
  Sets the ExecutorService to be used by send">set-agent-send-executor!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set-agent-send-off-executor%21" title="clojure.core/set-agent-send-off-executor!
([executor])
  Sets the ExecutorService to be used by send-off">set-agent-send-off-executor!</a></code></td>
              </tr>
              <tr class="even">
                <td>Block waiting</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/await" title="clojure.core/await
([&amp; agents])
  Blocks the current thread (indefinitely!) until all actions
  dispatched thus far, from this thread or agent, to the agent(s) have
  occurred.  Will block on failed agents.  Will never return if
  a failed agent is restarted with :clear-actions true or shutdown-agents was
called.">await</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/await-for" title="clojure.core/await-for
([timeout-ms &amp; agents])
  Blocks the current thread until all actions dispatched thus
  far (from this thread or agent) to the agents have occurred, or the
  timeout (in milliseconds) has elapsed. Returns logical false if
  returning due to timeout, logical true otherwise.">await-for</a></code></td>
              </tr>
              <tr class="odd">
                <td>Ref validators</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/set-validator%21" title="clojure.core/set-validator!
([iref validator-fn])
  Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
  side-effect-free fn of one argument, which will be passed the intended
  new state on any state change. If the new state is unacceptable, the
  validator-fn should return false or throw an exception. If the current state
(root
  value if var) is not acceptable to the new validator, an exception
  will be thrown and the validator will not be changed.">set-validator!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-validator" title="clojure.core/get-validator
([iref])
  Gets the validator-fn for a var/ref/agent/atom.">get-validator</a></code></td>
              </tr>
              <tr class="even">
                <td>Watchers</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/add-watch" title="clojure.core/add-watch
([reference key fn])
  Adds a watch function to an agent/atom/var/ref reference. The watch
  fn must be a fn of 4 args: a key, the reference, its old-state, its
  new-state. Whenever the reference's state might have been changed,
  any registered watches will have their functions called. The watch fn
  will be called synchronously, on the agent's thread if an agent,
  before any pending sends if agent or ref. Note that an atom's or
  ref's state may have changed again prior to the fn call, so use
  old/new-state rather than derefing the reference. Note also that watch
  fns may be called from multiple threads simultaneously. Var watchers
  are triggered only by root binding changes, not thread-local
  set!s. Keys must be unique per reference, and can be used to remove
  the watch with remove-watch, but are otherwise considered opaque by
  the watch mechanism.">add-watch</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/remove-watch" title="clojure.core/remove-watch
([reference key])
  Removes a watch (set by add-watch) from a reference">remove-watch</a></code></td>
              </tr>
              <tr class="odd">
                <td>Thread handling</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/shutdown-agents" title="clojure.core/shutdown-agents
([])
  Initiates a shutdown of the thread pools that back the agent
  system. Running actions will complete, but no new actions will be
  accepted">shutdown-agents</a></code></td>
              </tr>
              <tr class="even">
                <td>Error</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/error-handler" title="clojure.core/error-handler
([a])
  Returns the error-handler of agent a, or nil if there is none.
  See set-error-handler!">error-handler</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set-error-handler%21" title="clojure.core/set-error-handler!
([a handler-fn])
  Sets the error-handler of agent a to handler-fn.  If an action
  being run by the agent throws an exception or doesn't pass the
  validator fn, handler-fn will be called with two arguments: the
  agent and the exception.">set-error-handler!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/error-mode" title="clojure.core/error-mode
([a])
  Returns the error-mode of agent a.  See set-error-mode!">error-mode</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set-error-mode%21" title="clojure.core/set-error-mode!
([a mode-keyword])
  Sets the error-mode of agent a to mode-keyword, which must be
  either :fail or :continue.  If an action being run by the agent
  throws an exception or doesn't pass the validator fn, an
  error-handler may be called (see set-error-handler!), after which,
  if the mode is :continue, the agent will continue as if neither the
  action that caused the error nor the error itself ever happened.

  If the mode is :fail, the agent will become failed and will stop
  accepting new 'send' and 'send-off' actions, and any previously
  queued actions will be held until a 'restart-agent'.  Deref will
  still work, returning the state of the agent before the error.">set-error-mode!</a></code></td>
              </tr>
              <tr class="odd">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*agent*" title="clojure.core/*agent*
  The agent currently running an action on this thread, else nil">*agent*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/release-pending-sends" title="clojure.core/release-pending-sends
([])
  Normally, actions sent directly or indirectly during another action
  are held until the action completes (changes the agent's
  state). This function can be used to dispatch any pending sent
  actions immediately. This has no impact on actions sent during a
  transaction, which are still held until commit. If no action is
  occurring, does nothing. Returns the number of actions dispatched.">release-pending-sends</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Java Interoperation (<a href="https://clojure.org/reference/java_interop">clojure.org/reference/java_interop</a>)</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>General</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/_dot_dot" title="clojure.core/..
([x form] [x form &amp; more])
Macro
  form =&gt; fieldName-symbol or (instanceMethodName-symbol args*)

  Expands into a member access (.) of the first member on the first
  argument, followed by the next member on the result, etc. For
  instance:

  (.. System (getProperties) (get &quot;os.name&quot;))

  expands to:

  (. (. System (getProperties)) (get &quot;os.name&quot;))

  but is easier to write, read, and understand.">..</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doto" title="clojure.core/doto
([x &amp; forms])
Macro
  Evaluates x then calls all of the methods and functions with the
  value of x supplied at the front of the given arguments.  The forms
  are evaluated in order.  Returns x.

  (doto (new java.util.HashMap) (.put &quot;a&quot; 1) (.put &quot;b&quot; 2))">doto</a> Classname/ Classname. <a href="https://clojuredocs.org/clojure_core/clojure.core/new" title="new
  (Classname. args*)
  (new Classname args*)
Special Form
  The args, if any, are evaluated from left to right, and
  passed to the constructor of the class named by Classname. The
  constructed object is returned.

  Please see http://clojure.org/java_interop#new">new</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bean" title="clojure.core/bean
([x])
  Takes a Java object and returns a read-only implementation of the
  map abstraction based upon its JavaBean properties.">bean</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/comparator" title="clojure.core/comparator
([pred])
  Returns an implementation of java.util.Comparator based upon pred.">comparator</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/enumeration-seq" title="clojure.core/enumeration-seq
([e])
  Returns a seq on a java.util.Enumeration">enumeration-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/import" title="clojure.core/import
([&amp; import-symbols-or-lists])
Macro
  import-list =&gt; (package-symbol class-name-symbols*)

  For each name in class-name-symbols, adds a mapping from name to the
  class named by package.name to the current namespace. Use :import in the ns
  macro in preference to calling this directly.
Spec
  args: (* (alt :class (quotable simple-symbol?) :package-list (quotable
:clojure.core.specs.alpha/package-list)))
  ret: any?">import</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/iterator-seq" title="clojure.core/iterator-seq
([iter])
  Returns a seq on a java.util.Iterator. Note that most collections
  providing iterators implement Iterable and thus support seq directly.
  Seqs cache values, thus iterator-seq should not be used on any
  iterator that repeatedly returns the same mutable object.">iterator-seq</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/memfn" title="clojure.core/memfn
([name &amp; args])
Macro
  Expands into code that creates a fn that expects to be passed an
  object and any args and calls the named instance method on the
  object passing the args. Use when you want to treat a Java method as
  a first-class fn. name may be type-hinted with the method receiver's
  type in order to avoid reflective calls.">memfn</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/set!" title="set!
  (set! var-symbol expr)
  (set! (. instance-expr instanceFieldName-symbol) expr)
  (set! (. Classname-symbol staticFieldName-symbol) expr)
Special Form
  Used to set thread-local-bound vars, Java object instance
fields, and Java class static fields.

  Please see http://clojure.org/vars#set">set!</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/class" title="clojure.core/class
([x])
  Returns the Class of x">class</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/class_q" title="clojure.core/class?
([x])
  Returns true if x is an instance of Class">class?</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bases" title="clojure.core/bases
([c])
  Returns the immediate superclass and direct interfaces of c, if any">bases</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/supers" title="clojure.core/supers
([class])
  Returns the immediate and indirect superclasses and interfaces of c, if any">supers</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/type" title="clojure.core/type
([x])
  Returns the :type metadata of x, or its Class if none">type</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/gen-class" title="clojure.core/gen-class
([&amp; options])
Macro
  When compiling, generates compiled bytecode for a class with the
  given package-qualified :name (which, as all names in these
  parameters, can be a string or symbol), and writes the .class file
  to the *compile-path* directory.  When not compiling, does
  nothing. The gen-class construct contains no implementation, as the
  implementation will be dynamically sought by the generated class in
  functions in an implementing Clojure namespace. Given a generated
  class org.mydomain.MyClass with a method named mymethod, gen-class
  will generate an implementation that looks for a function named by
  (str prefix mymethod) (default prefix: &quot;-&quot;) in a
  Clojure namespace specified by :impl-ns
  (defaults to the current namespace). All inherited methods,
  generated methods, and init and main functions (see :methods, :init,
  and :main below) will be found similarly prefixed. By default, the
  static initializer for the generated class will attempt to load the
  Clojure support code for the class as a resource from the classpath,
  e.g. in the example case, ``org/mydomain/MyClass__init.class``. This
  behavior can be controlled by :load-impl-ns

  Note that methods with a maximum of 18 parameters are supported.

  In all subsequent sections taking types, the primitive types can be

[ documentation truncated.  Click link for the rest. ]">gen-class</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/gen-interface" title="clojure.core/gen-interface
([&amp; options])
Macro
  When compiling, generates compiled bytecode for an interface with
  the given package-qualified :name (which, as all names in these
  parameters, can be a string or symbol), and writes the .class file
  to the *compile-path* directory.  When not compiling, does nothing.

  In all subsequent sections taking types, the primitive types can be
  referred to by their Java names (int, float etc), and classes in the
  java.lang package can be used without a package qualifier. All other
  classes must be fully qualified.

  Options should be a set of key/value pairs, all except for :name are
  optional:

  :name aname

  The package-qualified name of the class to be generated

  :extends [interface ...]

  One or more interfaces, which will be extended by this interface.

  :methods [ [name [param-types] return-type], ...]

[ documentation truncated.  Click link for the rest. ]">gen-interface</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/definterface" title="clojure.core/definterface
([name &amp; sigs])
Macro
  Creates a new Java interface with the given name and method sigs.
  The method return types and parameter types may be specified with type hints,
  defaulting to Object if omitted.

  (definterface MyInterface
    (^int method1 [x])
    (^Bar method2 [^Baz b ^Quux q]))">definterface</a></code></td>
              </tr>
              <tr class="even">
                <td>Cast</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/boolean" title="clojure.core/boolean
([x])
  Coerce to boolean">boolean</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/byte" title="clojure.core/byte
([x])
  Coerce to byte">byte</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/short" title="clojure.core/short
([x])
  Coerce to short">short</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/char" title="clojure.core/char
([x])
  Coerce to char">char</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/int" title="clojure.core/int
([x])
  Coerce to int">int</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/long" title="clojure.core/long
([x])
  Coerce to long">long</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/float" title="clojure.core/float
([x])
  Coerce to float">float</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/double" title="clojure.core/double
([x])
  Coerce to double">double</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bigdec" title="clojure.core/bigdec
([x])
  Coerce to BigDecimal">bigdec</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bigint" title="clojure.core/bigint
([x])
  Coerce to BigInt">bigint</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/num" title="clojure.core/num
([x])
  Coerce to Number">num</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/cast" title="clojure.core/cast
([c x])
  Throws a ClassCastException if x is not a c, else returns x.">cast</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/biginteger" title="clojure.core/biginteger
([x])
  Coerce to BigInteger">biginteger</a></code></td>
              </tr>
              <tr class="odd">
                <td>Exceptions</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/throw" title="throw
  (throw expr)
Special Form
  The expr is evaluated and thrown, therefore it should
  yield an instance of some derivee of Throwable.

  Please see http://clojure.org/special_forms#throw">throw</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/try" title="try
  (try expr* catch-clause* finally-clause?)
Special Form
  catch-clause =&gt; (catch classname name expr*)
  finally-clause =&gt; (finally expr*)

  Catches and handles Java exceptions.

  Please see http://clojure.org/special_forms#try">try</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/catch" title="try
  (try expr* catch-clause* finally-clause?)
Special Form
  catch-clause =&gt; (catch classname name expr*)
  finally-clause =&gt; (finally expr*)

  Catches and handles Java exceptions.

  Please see http://clojure.org/special_forms#try">catch</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/finally" title="try
  (try expr* catch-clause* finally-clause?)
Special Form
  catch-clause =&gt; (catch classname name expr*)
  finally-clause =&gt; (finally expr*)

  Catches and handles Java exceptions.

  Please see http://clojure.org/special_forms#try">finally</a> <a href="https://clojuredocs.org/clojure_core/clojure.repl/pst" title="clojure.repl/pst
([] [e-or-depth] [e depth])
  Prints a stack trace of the exception, to the depth requested. If none
supplied, uses the root cause of the
  most recent repl exception (*e), and a depth of 12.">pst</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ex-info" title="clojure.core/ex-info
([msg map] [msg map cause])
  Create an instance of ExceptionInfo, a RuntimeException subclass
   that carries a map of additional data.">ex-info</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ex-data" title="clojure.core/ex-data
([ex])
  Returns exception data (a map) if ex is an IExceptionInfo.
   Otherwise returns nil.">ex-data</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/Throwable-%3Emap" title="clojure.core/Throwable-&gt;map
([o])
  Constructs a data representation for a Throwable with keys:
    :cause - root cause message
    :phase - error phase
    :via - cause chain, with cause keys:
             :type - exception class symbol
             :message - exception message
             :data - ex-data
             :at - top stack element
    :trace - root cause stack elements">Throwable-&gt;map</a> (1.9) <a href="https://clojuredocs.org/clojure_core/clojure.core/StackTraceElement-%3Evec" title="clojure.core/StackTraceElement-&gt;vec
([o])
  Constructs a data representation for a StackTraceElement: [class method file
line]">StackTraceElement-&gt;vec</a> (1.10) <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ex-cause" title="clojure.core/ex-cause
([ex])
  Returns the cause of ex if ex is a Throwable.
  Otherwise returns nil.">ex-cause</a> <a href="https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ex-message" title="clojure.core/ex-message
([ex])
  Returns the message attached to ex if ex is a Throwable.
  Otherwise returns nil.">ex-message</a> (clojure.main/) <a href="https://clojure.github.io/clojure/clojure.main-api.html#clojure.main/ex-triage" title="clojure.main/ex-triage
([datafied-throwable])
  Returns an analysis of the phase, error, cause, and location of an error that
occurred
  based on Throwable data, as returned by Throwable-&gt;map. All attributes other
than phase
  are optional:
    :clojure.error/phase - keyword phase indicator, one of:
      :read-source :compile-syntax-check :compilation :macro-syntax-check
:macroexpansion
      :execution :read-eval-result :print-eval-result
    :clojure.error/source - file name (no path)
    :clojure.error/path - source path
    :clojure.error/line - integer line number
    :clojure.error/column - integer column number
    :clojure.error/symbol - symbol being expanded/compiled/invoked
    :clojure.error/class - cause exception class symbol
    :clojure.error/cause - cause exception message
    :clojure.error/spec - explain-data for spec error">ex-triage</a> <a href="https://clojure.github.io/clojure/clojure.main-api.html#clojure.main/ex-str" title="clojure.main/ex-str
([{:clojure.error/keys [phase source path line column symbol class cause spec],
:as triage-data}])
  Returns a string from exception data, as produced by ex-triage.
  The first line summarizes the exception phase and location.
  The subsequent lines describe the cause.">ex-str</a> <a href="https://clojure.github.io/clojure/clojure.main-api.html#clojure.main/err->msg" title="clojure.main/err-&gt;msg
([e])
  Helper to return an error message string from an exception.">err-&gt;msg</a> <a href="https://clojure.github.io/clojure/clojure.main-api.html#clojure.main/report-error" title="clojure.main/report-error
([t &amp; {:keys [target], :or {target &quot;file&quot;}, :as opts}])
  Create and output an exception report for a Throwable to target.

  Options:
    :target - &quot;file&quot; (default), &quot;stderr&quot;, &quot;none&quot;

  If file is specified but cannot be written, falls back to stderr.">report-error</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Arrays</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/make-array" title="clojure.core/make-array
([type len] [type dim &amp; more-dims])
  Creates and returns an array of instances of the specified class of
  the specified dimension(s).  Note that a class object is required.
  Class objects can be obtained by using their imported or
  fully-qualified name.  Class objects for the primitive types can be
  obtained using, e.g., Integer/TYPE.">make-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/object-array" title="clojure.core/object-array
([size-or-seq])
  Creates an array of objects">object-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/boolean-array" title="clojure.core/boolean-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of booleans">boolean-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/byte-array" title="clojure.core/byte-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of bytes">byte-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/short-array" title="clojure.core/short-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of shorts">short-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/char-array" title="clojure.core/char-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of chars">char-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/int-array" title="clojure.core/int-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of ints">int-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/long-array" title="clojure.core/long-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of longs">long-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/float-array" title="clojure.core/float-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of floats">float-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/double-array" title="clojure.core/double-array
([size-or-seq] [size init-val-or-seq])
  Creates an array of doubles">double-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aclone" title="clojure.core/aclone
([array])
  Returns a clone of the Java array. Works on arrays of known
  types.">aclone</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/to-array" title="clojure.core/to-array
([coll])
  Returns an array of Objects containing the contents of coll, which
  can be any Collection.  Maps to java.util.Collection.toArray().">to-array</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/to-array-2d" title="clojure.core/to-array-2d
([coll])
  Returns a (potentially-ragged) 2-dimensional array of Objects
  containing the contents of coll, which can be any Collection of any
  Collection.">to-array-2d</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/into-array" title="clojure.core/into-array
([aseq] [type aseq])
  Returns an array with components set to the values in aseq. The array's
  component type is type if provided, or the type of the first value in
  aseq if present, or Object. All values in aseq must be compatible with
  the component type. Class objects for the primitive types can be obtained
  using, e.g., Integer/TYPE.">into-array</a></code></td>
              </tr>
              <tr class="even">
                <td>Use</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/aget" title="clojure.core/aget
([array idx] [array idx &amp; idxs])
  Returns the value at the index/indices. Works on Java arrays of all
  types.">aget</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset" title="clojure.core/aset
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on Java arrays of
  reference types. Returns val.">aset</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-boolean" title="clojure.core/aset-boolean
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of boolean. Returns val.">aset-boolean</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-byte" title="clojure.core/aset-byte
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of byte. Returns val.">aset-byte</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-short" title="clojure.core/aset-short
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of short. Returns val.">aset-short</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-char" title="clojure.core/aset-char
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of char. Returns val.">aset-char</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-int" title="clojure.core/aset-int
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of int. Returns val.">aset-int</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-long" title="clojure.core/aset-long
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of long. Returns val.">aset-long</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-float" title="clojure.core/aset-float
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of float. Returns val.">aset-float</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/aset-double" title="clojure.core/aset-double
([array idx val] [array idx idx2 &amp; idxv])
  Sets the value at the index/indices. Works on arrays of double. Returns val.">aset-double</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/alength" title="clojure.core/alength
([array])
  Returns the length of the Java array. Works on arrays of all
  types.">alength</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/amap" title="clojure.core/amap
([a idx ret expr])
Macro
  Maps an expression across an array a, using an index named idx, and
  return value named ret, initialized to a clone of a, then setting
  each element of ret to the evaluation of expr, returning the new
  array ret.">amap</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/areduce" title="clojure.core/areduce
([a idx ret init expr])
Macro
  Reduces an expression across an array a, using an index named idx,
  and return value named ret, initialized to init, setting ret to the
  evaluation of expr at each step, returning ret.">areduce</a></code></td>
              </tr>
              <tr class="odd">
                <td>Cast</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/booleans" title="clojure.core/booleans
([xs])
  Casts to boolean[]">booleans</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/bytes" title="clojure.core/bytes
([xs])
  Casts to bytes[]">bytes</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/shorts" title="clojure.core/shorts
([xs])
  Casts to shorts[]">shorts</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/chars" title="clojure.core/chars
([xs])
  Casts to chars[]">chars</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/ints" title="clojure.core/ints
([xs])
  Casts to int[]">ints</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/longs" title="clojure.core/longs
([xs])
  Casts to long[]">longs</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/floats" title="clojure.core/floats
([xs])
  Casts to float[]">floats</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/doubles" title="clojure.core/doubles
([xs])
  Casts to double[]">doubles</a></code></td>
              </tr>
            </tbody>
          </table>
          <h3>Proxy (<a href="https://github.com/cemerick/clojure-type-selection-flowchart">Clojure type selection flowchart</a>)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/proxy" title="clojure.core/proxy
([class-and-interfaces args &amp; fs])
Macro
  class-and-interfaces - a vector of class names

  args - a (possibly empty) vector of arguments to the superclass
  constructor.

  f =&gt; (name [params*] body) or
  (name ([params*] body) ([params+] body) ...)

  Expands to code which creates a instance of a proxy class that
  implements the named class/interface(s) by calling the supplied
  fns. A single class, if provided, must be first. If not provided it
  defaults to Object.

  The interfaces names must be valid interface types. If a method fn
  is not provided for a class method, the superclass method will be
  called. If a method fn is not provided for an interface method, an
  UnsupportedOperationException will be thrown should it be
  called. Method fns are closures and can capture the environment in
  which proxy is called. Each method fn takes an additional implicit
  first arg, which is bound to 'this. Note that while method fns can
  be provided to override protected methods, they have no other access
  to protected members, nor to super, as these capabilities cannot be

[ documentation truncated.  Click link for the rest. ]">proxy</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/get-proxy-class" title="clojure.core/get-proxy-class
([&amp; bases])
  Takes an optional single class followed by zero or more
  interfaces. If not supplied class defaults to Object.  Creates an
  returns an instance of a proxy class derived from the supplied
  classes. The resulting value is cached and used for any subsequent
  requests for the same class set. Returns a Class object.">get-proxy-class</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/construct-proxy" title="clojure.core/construct-proxy
([c &amp; ctor-args])
  Takes a proxy class and any arguments for its superclass ctor and
  creates and returns an instance of the proxy.">construct-proxy</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/init-proxy" title="clojure.core/init-proxy
([proxy mappings])
  Takes a proxy instance and a map of strings (which must
  correspond to methods of the proxy superclass/superinterfaces) to
  fns (which must take arguments matching the corresponding method,
  plus an additional (explicit) first arg corresponding to this, and
  sets the proxy's fn map.  Returns the proxy.">init-proxy</a></code></td>
              </tr>
              <tr class="even">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/proxy-mappings" title="clojure.core/proxy-mappings
([proxy])
  Takes a proxy instance and returns the proxy's fn map.">proxy-mappings</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/proxy-super" title="clojure.core/proxy-super
([meth &amp; args])
Macro
  Use to call a superclass method in the body of a proxy method.
  Note, expansion captures 'this">proxy-super</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/update-proxy" title="clojure.core/update-proxy
([proxy mappings])
  Takes a proxy instance and a map of strings (which must
  correspond to methods of the proxy superclass/superinterfaces) to
  fns (which must take arguments matching the corresponding method,
  plus an additional (explicit) first arg corresponding to this, and
  updates (via assoc) the proxy's fn map. nil can be passed instead of
  a fn, in which case the corresponding method will revert to the
  default behavior. Note that this function can be used to update the
  behavior of an existing instance without changing its identity.
  Returns the proxy.">update-proxy</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h3>Zippers (clojure.zip/)</h3>
          <table>
            <tbody>
              <tr class="odd">
                <td>Create</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/zipper" title="clojure.zip/zipper
([branch? children make-node root])
  Creates a new zipper structure.

  branch? is a fn that, given a node, returns true if can have
  children, even if it currently doesn't.

  children is a fn that, given a branch node, returns a seq of its
  children.

  make-node is a fn that, given an existing node and a seq of
  children, returns a new branch node with the supplied children.
  root is the root node.">zipper</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/seq-zip" title="clojure.zip/seq-zip
([root])
  Returns a zipper for nested sequences, given a root sequence">seq-zip</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/vector-zip" title="clojure.zip/vector-zip
([root])
  Returns a zipper for nested vectors, given a root vector">vector-zip</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/xml-zip" title="clojure.zip/xml-zip
([root])
  Returns a zipper for xml elements (as from xml/parse),
  given a root element">xml-zip</a></code></td>
              </tr>
              <tr class="even">
                <td>Get loc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/up" title="clojure.zip/up
([loc])
  Returns the loc of the parent of the node at this loc, or nil if at
  the top">up</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/down" title="clojure.zip/down
([loc])
  Returns the loc of the leftmost child of the node at this loc, or
  nil if no children">down</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/left" title="clojure.zip/left
([loc])
  Returns the loc of the left sibling of the node at this loc, or nil">left</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/right" title="clojure.zip/right
([loc])
  Returns the loc of the right sibling of the node at this loc, or nil">right</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/leftmost" title="clojure.zip/leftmost
([loc])
  Returns the loc of the leftmost sibling of the node at this loc, or self">leftmost</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/rightmost" title="clojure.zip/rightmost
([loc])
  Returns the loc of the rightmost sibling of the node at this loc, or self">rightmost</a></code></td>
              </tr>
              <tr class="odd">
                <td>Get seq</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/lefts" title="clojure.zip/lefts
([loc])
  Returns a seq of the left siblings of this loc">lefts</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/rights" title="clojure.zip/rights
([loc])
  Returns a seq of the right siblings of this loc">rights</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/path" title="clojure.zip/path
([loc])
  Returns a seq of nodes leading to this loc">path</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/children" title="clojure.zip/children
([loc])
  Returns a seq of the children of node at loc, which must be a branch">children</a></code></td>
              </tr>
              <tr class="even">
                <td>'Change'</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/make-node" title="clojure.zip/make-node
([loc node children])
  Returns a new branch node, given an existing node and new
  children. The loc is only used to supply the constructor.">make-node</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/replace" title="clojure.zip/replace
([loc node])
  Replaces the node at this loc, without moving">replace</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/edit" title="clojure.zip/edit
([loc f &amp; args])
  Replaces the node at this loc with the value of (f node args)">edit</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/insert-child" title="clojure.zip/insert-child
([loc item])
  Inserts the item as the leftmost child of the node at this loc,
  without moving">insert-child</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/insert-left" title="clojure.zip/insert-left
([loc item])
  Inserts the item as the left sibling of the node at this loc,
 without moving">insert-left</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/insert-right" title="clojure.zip/insert-right
([loc item])
  Inserts the item as the right sibling of the node at this loc,
  without moving">insert-right</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/append-child" title="clojure.zip/append-child
([loc item])
  Inserts the item as the rightmost child of the node at this loc,
  without moving">append-child</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/remove" title="clojure.zip/remove
([loc])
  Removes the node at loc, returning the loc that would have preceded
  it in a depth-first walk.">remove</a></code></td>
              </tr>
              <tr class="odd">
                <td>Move</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/next" title="clojure.zip/next
([loc])
  Moves to the next loc in the hierarchy, depth-first. When reaching
  the end, returns a distinguished loc detectable via end?. If already
  at the end, stays there.">next</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/prev" title="clojure.zip/prev
([loc])
  Moves to the previous loc in the hierarchy, depth-first. If already
  at the root, returns nil.">prev</a></code></td>
              </tr>
              <tr class="even">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.zip/root" title="clojure.zip/root
([loc])
  zips all the way up and returns the root node, reflecting any
 changes.">root</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/node" title="clojure.zip/node
([loc])
  Returns the node at loc">node</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/branch_q" title="clojure.zip/branch?
([loc])
  Returns true if the node at loc is a branch">branch?</a> <a href="https://clojuredocs.org/clojure_core/clojure.zip/end_q" title="clojure.zip/end?
([loc])
  Returns true if loc represents the end of a depth-first walk">end?</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
        <div class="section">
          <h2>Other</h2>
          <table>
            <tbody>
              <tr class="odd">
                <td>XML</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.xml/parse" title="clojure.xml/parse
([s] [s startparse])
  Parses and loads the source s, which can be a File, InputStream or
  String naming a URI. Returns a tree of the xml/element struct-map,
  which has the keys :tag, :attrs, and :content. and accessor fns tag,
  attrs, and content. Other parsers can be supplied by passing
  startparse, a fn taking a source and a ContentHandler and returning
  a parser.

  Prior to 1.11, used startparse-sax by default. As of 1.11, uses
  startparse-sax-safe, which disables XXE (XML External Entity)
  processing. Pass startparse-sax to revert to prior behavior.">clojure.xml/parse</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/xml-seq" title="clojure.core/xml-seq
([root])
  A tree seq on the xml elements as per xml/parse">xml-seq</a></code></td>
              </tr>
              <tr class="even">
                <td>REPL</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*1" title="clojure.core/*1
  bound in a repl thread to the most recent value printed">*1</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*2" title="clojure.core/*2
  bound in a repl thread to the second most recent value printed">*2</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*3" title="clojure.core/*3
  bound in a repl thread to the third most recent value printed">*3</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*e" title="clojure.core/*e
  bound in a repl thread to the most recent exception caught by the repl">*e</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*print-dup*" title="clojure.core/*print-dup*
  When set to logical true, objects will be printed in a way that preserves
  their type when read in later.

  Defaults to false.">*print-dup*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*print-length*" title="clojure.core/*print-length*
  *print-length* controls how many items of each collection the
  printer will print. If it is bound to logical false, there is no
  limit. Otherwise, it must be bound to an integer indicating the maximum
  number of items of each collection to print. If a collection contains
  more items, the printer will print items up to the limit followed by
  '...' to represent the remaining items. The root binding is nil
  indicating no limit.">*print-length*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*print-level*" title="clojure.core/*print-level*
  *print-level* controls how many levels deep the printer will
  print nested objects. If it is bound to logical false, there is no
  limit. Otherwise, it must be bound to an integer indicating the maximum
  level to print. Each argument to print is at level 0; if an argument is a
  collection, its items are at level 1; and so on. If an object is a
  collection and is at a level greater than or equal to the value bound to
  *print-level*, the printer prints '#' to represent it. The root binding
  is nil indicating no limit.">*print-level*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*print-meta*" title="clojure.core/*print-meta*
  If set to logical true, when printing an object, its metadata will also
  be printed in a form that can be read back by the reader.

  Defaults to false.">*print-meta*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*print-readably*" title="clojure.core/*print-readably*
  When set to logical false, strings and characters will be printed with
  non-alphanumeric characters converted to the appropriate escape sequences.

  Defaults to true">*print-readably*</a></code></td>
              </tr>
              <tr class="odd">
                <td>Code</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/*compile-files*" title="clojure.core/*compile-files*
  Set to true when compiling files, false otherwise.">*compile-files*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*compile-path*" title="clojure.core/*compile-path*
  Specifies the directory where 'compile' will write out .class
  files. This directory must be in the classpath for 'compile' to
  work.

  Defaults to &quot;classes&quot;">*compile-path*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*file*" title="clojure.core/*file*
  The path of the file being evaluated, as a String.

  When there is no file, e.g. in the REPL, the value is not defined.">*file*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*warn-on-reflection*" title="clojure.core/*warn-on-reflection*
  When set to true, the compiler will emit warnings when reflection is
  needed to resolve Java method calls or field accesses.

  Defaults to false.">*warn-on-reflection*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/compile" title="clojure.core/compile
([lib])
  Compiles the namespace named by the symbol lib into a set of
  classfiles. The source for the lib must be in a proper
  classpath-relative directory. The output files will go into the
  directory specified by *compile-path*, and that directory too must
  be in the classpath.">compile</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/loaded-libs" title="clojure.core/loaded-libs
([])
  Returns a sorted set of symbols naming the currently loaded libs">loaded-libs</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/test" title="clojure.core/test
([v])
  test [v] finds fn at key :test in var metadata and calls it,
  presuming failure will throw exception">test</a></code></td>
              </tr>
              <tr class="even">
                <td>Misc</td>
                <td><code><a href="https://clojuredocs.org/clojure_core/clojure.core/eval" title="clojure.core/eval
([form])
  Evaluates the form data structure (not text!) and returns the result.">eval</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/force" title="clojure.core/force
([x])
  If x is a Delay, returns the (possibly cached) value of its expression, else
returns x">force</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/hash" title="clojure.core/hash
([x])
  Returns the hash code of its argument. Note this is the hash code
  consistent with =, and thus is different than .hashCode for Integer,
  Short, Byte and Clojure collections.">hash</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/name" title="clojure.core/name
([x])
  Returns the name String of a string, symbol or keyword.">name</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*clojure-version*" title="clojure.core/*clojure-version*
  The version info for Clojure core, as a map containing :major :minor
  :incremental and :qualifier keys. Feature releases may increment
  :minor and/or :major, bugfix releases will increment :incremental.
  Possible values of :qualifier include &quot;GA&quot;, &quot;SNAPSHOT&quot;, &quot;RC-x&quot; &quot;BETA-x&quot;">*clojure-version*</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/clojure-version" title="clojure.core/clojure-version
([])
  Returns clojure version as a printable string.">clojure-version</a> <a href="https://clojuredocs.org/clojure_core/clojure.core/*command-line-args*" title="clojure.core/*command-line-args*
  A sequence of the supplied command line arguments, or nil if
  none were supplied">*command-line-args*</a> (1.11) <a href="https://clojuredocs.org/clojure_core/clojure.core/random-uuid" title="clojure.core/random-uuid
([])
  Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).

  See:
https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--">random-uuid</a></code></td>
              </tr>
              <tr class="odd">
                <td>Browser / Shell</td>
                <td><code>(clojure.java.browse/) <a href="https://clojuredocs.org/clojure_core/clojure.java.browse/browse-url" title="clojure.java.browse/browse-url
([url])
  Open url in a browser">browse-url</a> (clojure.java.shell/) <a href="https://clojuredocs.org/clojure_core/clojure.java.shell/sh" title="clojure.java.shell/sh
([&amp; args])
  Passes the given strings to Runtime.exec() to launch a sub-process.

  Options are

  :in      may be given followed by any legal input source for
           clojure.java.io/copy, e.g. InputStream, Reader, File, byte[],
           or String, to be fed to the sub-process's stdin.
  :in-enc  option may be given followed by a String, used as a character
           encoding name (for example &quot;UTF-8&quot; or &quot;ISO-8859-1&quot;) to
           convert the input string specified by the :in option to the
           sub-process's stdin.  Defaults to UTF-8.
           If the :in option provides a byte array, then the bytes are passed
           unencoded, and this option is ignored.
  :out-enc option may be given followed by :bytes or a String. If a
           String is given, it will be used as a character encoding
           name (for example &quot;UTF-8&quot; or &quot;ISO-8859-1&quot;) to convert
           the sub-process's stdout to a String which is returned.
           If :bytes is given, the sub-process's stdout will be stored
           in a byte array and returned.  Defaults to UTF-8.
  :env     override the process env with a map (or the underlying Java
           String[] if you are a masochist).
  :dir     override the process dir with a String or java.io.File.

[ documentation truncated.  Click link for the rest. ]">sh</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.shell/with-sh-dir" title="clojure.java.shell/with-sh-dir
([dir &amp; forms])
Macro
  Sets the directory for use with sh, see sh for details.">with-sh-dir</a> <a href="https://clojuredocs.org/clojure_core/clojure.java.shell/with-sh-env" title="clojure.java.shell/with-sh-env
([env &amp; forms])
Macro
  Sets the environment for use with sh, see sh for details.">with-sh-env</a></code></td>
              </tr>
            </tbody>
          </table>
        </div><!-- /section -->
      </div><!-- /column -->
    </div><!-- /page -->
